less ai-agent-competency-matrix

AI Agent Competency Matrix

A companion to the Programmer Competency Matrix, for working with AI coding agents. Same scale, 13 skills, from 2ⁿ (level 0) to log(n) (level 3), and each level includes the ones below it.

The top level isn't the most autonomy. It's picking the right amount for the task, and being able to show the result works.

Written in October 2026. The tools will change faster than the skills, so tool names live in the notes, not the cells.

directing

skill
2ⁿ level 0
n² level 1
n level 2
log(n) level 3
planning and specs

Agents copy whatever precedent they find, so the first patterns in a codebase matter more than ever.

2ⁿTypes “fix this” and accepts whatever comes back
n²Asks the agent for its plan before it writes code, and reads it
nWrites or reviews a spec before any code: scope, files touched, risks, and how “done” will be checked. Spends more time planning than prompting.
log(n)Owns the boundaries – schemas, API contracts, architecture – and lets agents fill in between. Pushes for the simplest design, because agents rarely propose deleting anything.
task sizing
2ⁿHands over a whole feature in one prompt
n²Breaks work into steps, but the steps are whatever the agent suggested
nOne concern per task and per PR, each small enough to verify on its own
log(n)Treats a task that can’t be done in one shot as a signal – the code is tangled, the spec is unclear or the task is too big – and fixes the cause
autonomy calibration

More autonomy isn’t a higher level. Picking the right amount is.

2ⁿOne mode for everything: approves every keystroke, or skips every permission prompt
n²Adjusts how much rope to give the agent by feel
nMatches autonomy to how crisply “done” can be checked and what a mistake costs: throwaway scripts run free, auth and payments get read line by line
log(n)Can explain the choice for any task, knows when not to use an agent at all, and changes the codebase so more work becomes safe to delegate

verifying

skill
2ⁿ level 0
n² level 1
n level 2
log(n) level 3
verification

Most people go through a valley here: the step after the honeymoon is learning to distrust the output.

2ⁿTakes “done” at face value
n²Runs the tests and skims the diff
nDemands evidence – test output, repro steps, screenshots – checks that tests exercise behaviour rather than mocks, and reads critical logic line by line
log(n)Builds the harness the agent checks itself against – types, tests, invariants, checks it can run – so human review goes to what only a human can judge
reviewable output

Generating code got cheap; reviewing it didn’t. Whoever reviews absorbs the cost of everything the author didn’t check.

2ⁿOpens 100-file PRs with no description
n²Understands every line they submit and describes the change
nShips stacked, single-concern PRs with the evidence attached, sized for a quick review
log(n)Has a separate checker – a fresh context or a different model – review the work before a human does, and shapes how review scales as the team’s output grows

compounding

skill
2ⁿ level 0
n² level 1
n level 2
log(n) level 3
context and instruction files

E.g. AGENTS.md, CLAUDE.md, Cursor rules. A stale instruction file is worse than none, because agents follow it over the code.

2ⁿRe-explains the project every session
n²Has a project instruction file
nKeeps it short and current: build and test commands, conventions, what not to touch. Tells the agent that existing code wins when the docs disagree.
log(n)Treats the file as an intake point, not a permanent home: prunes it, moves rules into skills, tests and lints, and shares it with the team under version control
turning corrections into infrastructure

The fix is always infrastructure, not effort.

2ⁿCorrects the same mistake every session
n²Adds a line to the instruction file after the third time
nThe second time a mistake shows up, it becomes a lint rule, a type, a test or a hook
log(n)Keeps a log of agent mistakes and reviews it; the codebase makes whole classes of mistakes impossible rather than discouraged
skills, tools and hooks

E.g. skills, slash commands, MCP servers, hooks. Most elaborate setups lose to a simple one that fixes the mistakes you actually make.

2ⁿUses the default install
n²Uses built-in modes like planning and adds a few off-the-shelf tool integrations
nWrites skills for work they repeat and hooks for rules that must never be skipped
log(n)Adds a layer only when the simpler one has failed, keeps the setup small, and builds tools the rest of the team uses

systems

skill
2ⁿ level 0
n² level 1
n level 2
log(n) level 3
orchestration

E.g. git worktrees, subagents, herdr, Orca, T3 Code. Parallel agents on overlapping files just manufacture review work.

2ⁿOne session at a time, waiting on it
n²Runs a second agent on unrelated work
nRuns several agents in parallel in isolated worktrees, on work that doesn’t overlap, and integrates the results cleanly
log(n)Designs agent graphs – planner, workers, reviewers, handoffs and an escalation path to a human – and knows when a single writer beats a graph
models and harnesses

E.g. Claude Code, Codex, OpenCode, Cursor; open-weight models like DeepSeek, Qwen and Kimi.

2ⁿOne tool and one model, out of habit; no idea what a session costs
n²Has tried the alternatives and knows roughly what each costs
nRoutes work by strength and cost – a strong model to plan, a cheap one for simple edits, another vendor’s model to review – and keeps config portable across tools
log(n)Coordinates mixed fleets of closed and open-weight models across harnesses, measures cost and quality per outcome, and can swap any part without rebuilding the workflow
autonomous pipelines
2ⁿEvery agent run is started and checked by hand
n²Agents run in CI for narrow jobs, like review comments or lint fixes
nScheduled or event-driven agents handle bounded classes of task, behind gates and with an audit trail
log(n)Builds end-to-end loops from issue to investigation, fix, verification and deploy, with human approval scaled to risk, monitoring of the agents themselves, a kill switch and rollback – and knows which work should never run unattended
security and permissions

Prompts are not a security boundary.

2ⁿSkips permission prompts on a machine with production credentials
n²Reads permission prompts before approving them
nSandboxes agents, uses allowlists, keeps secrets where the agent can’t read them, and treats anything fetched – web pages, issues, PRs, tool output – as untrusted
log(n)Designs the blast radius of unattended agents: least privilege, short-lived credentials, hooks that can deny, and a threat model for prompt injection through every input

you

skill
2ⁿ level 0
n² level 1
n level 2
log(n) level 3
keeping your own skills

In Anthropic’s 2026 study, engineers who delegated code generation while learning a new library understood it less well; those who used the AI to ask questions didn’t.

2ⁿCan’t explain code they shipped
n²Asks the agent to explain what it wrote
nWhen learning something new, asks conceptual questions and writes the core themselves instead of delegating it
log(n)Knows which skills they need to keep sharp, practises them deliberately, and teaches juniors to use agents without skipping the learning