AI Competency Standards

The process of breaking text into atomic units (tokens) for LLM processing. Understanding cost, limits, and how "thinking" is measured in tokens.

Strategies for managing the finite memory of an LLM. Includes sliding windows, RAG, and "compacting" history to prevent data loss.

The ability to pull, run, and manage open-source models (Llama, Mistral) offline using tools like Ollama or LM Studio.

The heuristic process of choosing the right model (speed vs. reasoning vs. cost) for a specific task (e.g., Haiku for docs, Sonnet for code).

Identifying hallucinations, training data bias, and safety guardrails. Differentiating between "safety refusals" and "inability."

Teaching the model new behaviors via prompts and data in the current context window without fine-tuning weights.

Moving through the OS file system using `cd`, `ls/dir`, `pwd`, and understanding relative vs. absolute paths.

Creating (`touch`, `mkdir`), moving (`mv`), and deleting (`rm`) files purely via command line interfaces.

Structuring knowledge in `.md` files (headers, lists, code blocks) for optimal AI ingestion and human readability.

Safely handling API keys using `.env` files and environment variables, ensuring secrets aren't hardcoded or pushed to git.

Tracking changes, creating commits, and managing project history. Interacting with GitHub via CLI/Copilot.

Navigating Visual Studio Code, managing extensions, and using the integrated terminal and command palette.

Creating persistent instructions (e.g., `agents.md` or System Messages) that define an agent's long-term behavior and rules.

Crafting specific roles (e.g., "Ruthless Critic", "Senior Architect") to elicit specialized responses and tones.

Prompting techniques that force the AI to explain its reasoning step-by-step before delivering a final answer, reducing error rates.

The architecture allowing LLMs to "break out" of the chat to use calculators, web search, or file system tools.

Coordinating multiple distinct agents (e.g., a "Researcher" and a "Writer") to collaborate on a single complex task.

Using "Plan Mode" to create a specification first, then executing code, then verifying the output against the spec.

The skill of guiding an agent through multi-turn corrections using feedback loops rather than expecting perfection in one shot.

Grounding user queries in specific external documents or databases to increase accuracy and reduce hallucination.

Using AI as a "Red Team" or opponent to critique logic, find fallacies, and strengthen arguments.

Using AI to parse messy text/notes into clean formats like Tables, JSON, or CSV for analysis.

Generating code to create diagrams, flowcharts, and Gantt charts from textual data descriptions.

Condensing multiple complex sources into cohesive summaries, identifying key technical trends and insights.

Co-authoring with AI where the human directs flow and the AI handles drafting, ensuring the human voice remains dominant.

Connecting local AI models to external tools and APIs via the Model Context Protocol (MCP), enabling "skills."

Creating a self-sustaining agentic clone containing specific knowledge and personality traits.

Running agents that have full OS-level access to read/write files and execute commands autonomously.

Using AI to write and execute Python scripts that automate common file system or data tasks.

Using models that can "see" and "hear" by providing images or audio as input for analysis.

Applying AI agents to geospatial tasks, libraries (Folium, Skyfield), and coordinate systems.

Connecting personalized data streams (Calendar, Email) to local AI agents securely for proactive assistance.

Structuring projects with clear folder layouts, README files, venv/requirements.txt, and single-command rerun instructions so work is reproducible across machines.

Specializing a foundation model's behavior for a specific domain using LoRA adapters, Trainer APIs, and local fine-tuning pipelines.

Maintaining claim-to-citation discipline, disclosing AI usage in scholarly work, and verifying references to avoid hallucinated citations.

Publishing AI-powered applications to platforms like HuggingFace Spaces, GitHub Pages, or local servers for live demonstration and sharing.

The ability to leverage LLM "World Models" for zero-shot geographic classification, land-cover analysis, and spatial troubleshooting.

Identifying and mitigating risks associated with deepfake satellite imagery, synthetic maps, and geopolitical misinformation.

Integrating AI-generated data into interactive map-based stories and dashboards using libraries like LeafletJS and Folium.

Formalizing AI collaboration into "Standard Operating Procedures" within documentation (e.g., agents.md) to ensure reproducibility in agentic workflows.