The 17 AI-Native Developer Skills

What the 17 skills are

The 17 AI-native skills are the operational backbone of the 7-level AI-Native Developer model. The levels tell you how mature you are (L1 Chat-Assisted through L7 Universal AI Creator); the 17 skills tell you what you actually do to get there. Every skill is tied to the level at which it becomes the norm, has a numeric KPI that exposes whether you really do it, and comes with the tools ProCoders recommends to do it well.

Read the skills as a progression, not a flat list. Skill #1 (code through an agent) switches on at L2. The L3 cluster makes the agent trustworthy: MCP, skills and plugins, project memory, planning, verification. The big L4 cluster turns you from a coder into a director: research, harnesses, parallel agents, model routing, evals, worktrees, remote control, safety gates, code review, and demos. Skill #12 (full autonomous PRD-to-result orchestration) is the L5 capstone.

The 17 skills at a glance

#	Skill	Norm from	What it proves
1	I have Claude (or equivalent) and don't write code by hand	L2	The agent is your main production mechanism, not a chat consultant
2	MCP installed	L3	The agent is wired to your real sources: docs, repo, DB, issues
3	Skills and plugins installed	L3	A repeatable workflow, not ad-hoc prompting
4	Project memory as part of the repo	L3	The project's knowledge lives in the repo, not just your head
5	Plan-before-code	L3	No implementation starts without an approved plan
6	Playground and deep-research skills while planning	L4	Hard tasks get researched and prototyped before code
7	Builds project-specific harnesses; turns repeats into skills	L4	You productize recurring problems instead of re-prompting
8	Parallel agents / subagent-driven development	L4	You run a team of roles, not one chat
9	Verification harness — the AI tests itself	L3	Evidence over trust: the agent proves its work
10	Model routing for speed and tokens	L4	The right model for each job, tracked and justified
11	Eval-driven improvement / acceptance-criteria loop	L4	Every ticket has acceptance criteria the agent must meet
12	Orchestrates a full autonomous PRD-to-result cycle (>5h)	L5	The agent runs a delivery loop while you supervise
13	Concurrent development via worktrees	L4	Multiple tasks run isolated, without file collisions
14	Remote mode with notifications / mobile control	L4	You steer long-running agents from anywhere
15	Configures hooks / permissions / safety gates	L4	Deterministic guardrails, zero leaked secrets
16	AI code review as a separate process	L4	The writer is never the reviewer
17	Result demonstration: video demo, interactive report	L4	Shipping includes showing the result, generated via AI

The 17 skills in depth

Agentic coding & model routing (skills 1, 10)

1. I have Claude (or equivalent) and don't write code by hand (L2). You use an AI agent as the primary mechanism to write, change, and refactor code; you touch the keyboard only for surgical fixes, critical patches, or architecture calls. KPI: baseline is at least 80% of routine code through the agent, strong is 100%, with a minimum of one AI-generated PR per week. Tools: Claude Code as default, with Codex, Cursor, or Antigravity acceptable; artifacts are PRs, agent logs, and diff summaries. See the agentic coding tooling map.

10. Model routing for speed and tokens (L4). You pick the model to fit the job: a strong reasoning model for architecture and debugging, a fast one for implementation, a code model for coding and review, a cheap one for docs and summaries. KPI: for tasks over 2 hours the model choice is recorded, with a minimum of 2 model tiers; seniors run 3+ models/routes plus a cost/time log per PR. Tools: Claude Opus/Sonnet, Codex, Cursor models, Antigravity. More on routing in the tooling guide.

Tooling & context (skills 2, 3, 4)

2. MCP installed (L3). You connect the agent to working sources: documentation, GitHub, the database, Linear/Jira, the browser, Context7, Supabase/Postgres, logs, CI/CD — and you understand permissions and blast radius. KPI: at least 2 working MCP per project, 4+ for seniors (including docs/library lookup and issue/repo access), with 0 exposed secrets. Tools: .mcp.json, Context7 MCP, GitHub MCP, Supabase/Postgres MCP, Playwright/browser MCP. See the tooling guide.

3. Skills and plugins installed (L3). You use the skill/plugin system as your standard workflow for planning, TDD, review, debugging, docs, harnesses, and deployment. KPI: at least 5 active skills, with at least 3 actually used across your last 5 tasks; seniors can author their own skill. Tools: the Superpowers plugin (Anthropic's official marketplace), anthropics/claude-code-skills, Superpowers-V, Claude /skills, Codex skills/plugins; artifacts are skills/*/SKILL.md and a skill usage log.

4. Project memory as part of the repo (L3). You maintain the project's memory — architecture, rules, conventions, known issues, test commands, library decisions, domain facts — and update it after tasks, mistakes, and reviews. KPI: every production repo has an AGENTS.md or CLAUDE.md, with at least 1 update after each significant PR, and memory never goes stale beyond 14 days. Tools: AGENTS.md, CLAUDE.md, .github/copilot-instructions.md, docs/superpowers/*.

Planning & research (skills 5, 6)

5. Plan-before-code (L3). Before any code, the agent studies the repo and produces a plan: file map, risks, acceptance criteria, test strategy, rollback strategy. No plan, no code. KPI: 100% of tasks over 2 hours have a plan artifact (goal, affected files, tasks, verification, rollback), and implementation cannot start without an approved plan. Tools: Superpowers brainstorming and writing-plans, Claude Plan Mode, the premortem skill; artifacts live in docs/superpowers/plans/.

6. Playground and deep-research skills while planning (L4). For complex or unfamiliar work you research first — docs, APIs, competitors, user pain, edge cases, fresh library versions, deprecation risks — and can build a PoC or playground before implementation. KPI: for tasks over 4 hours or in an unknown domain, at least 1 research note plus 3 verified sources/docs or a PoC, and 0 decisions built on stale libraries without reason. Tools: Superpowers brainstorming, the Playground Tool and AskUserTool, and Context7 for documentation validation.

Verification & quality (skills 9, 11, 16)

9. Verification harness — the AI tests itself (L3). You stop spending your time on manual testing and instead build a harness where the agent runs tests, evals, build, lint, typecheck, and security checks, then fixes itself until they pass. KPI: 80% of PRs carry evidence checks (90–95% for seniors), manual QA is at most 20% of task time, and a PR without evidence is not done. Tools: Superpowers test-driven-development and verification-before-completion, nizos/tdd-guard, Claude /run and /verify, plus CI, Jest/Vitest/Pytest, and Playwright.

11. Eval-driven improvement / acceptance-criteria loop (L4). The agent runs a loop: implement, run checks, compare against acceptance criteria and evals, fix, rerun, produce evidence. Not "done and trusted" but "proven and passed." KPI: every ticket has acceptance criteria; AI/RAG/agentic features get 5–20 eval cases; critical eval pass rate is at least 95%, and failed loops are logged. Tools: Superpowers executing-plans, Promptfoo/evals, custom eval scripts in CI; artifacts are evals/ and acceptance.md.

16. AI code review as a separate process (L4). You split production from control: the implementer is never the reviewer. A reviewer checks spec and code quality; a tester/security agent checks the harness, regressions, and vulnerabilities. KPI: for any PR beyond a small change, 100% get an independent AI review; critical PRs get 3 agents (writer, reviewer, tester/security), and merging without a review report is forbidden. Tools: Superpowers requesting-code-review and receiving-code-review, the official Anthropic Code Review plugin (/code-review), Codex review, CodeRabbit.

Orchestration & autonomy (skills 7, 8, 12, 13, 14)

7. Builds project-specific harnesses; turns repeats into skills (L4). When a problem recurs, you don't re-prompt — you build a reusable skill, plugin, or harness (technical, expert, QA, security, migration, refactoring, docs). KPI: after 2–3 repeats of one problem a skill/playbook/harness should exist; a mature repo has at least 3 project-specific skills. Tools: Superpowers writing-skills, test-driven-development, systematic-debugging; artifacts are SKILL.md, scripts/, and references/.

8. Parallel agents / subagent-driven development (L4). You launch a group of roles — researcher, planner, implementer, reviewer, tester, security reviewer, docs writer — that stay independent and don't pollute each other's context. KPI: a complex task uses at least 3 agent roles (4–6 for seniors), with at least 1 independent reviewer per meaningful PR. Tools: Superpowers subagent-driven-development and dispatching-parallel-agents, ruvnet/ruflo, wshobson/agents, Claude subagents.

12. Orchestrates a full autonomous PRD-to-result cycle, over 5 hours (L5). You run a delivery loop: PRD, decomposition, tickets, agent allocation, implementation, verification, review, PR-ready result — while you only supervise and unblock. KPI: a 5+ hour autonomous run with at most 3 human interventions, and at least 2 completed autonomous cycles per developer per month. Tools: Claude Code with Superpowers and Superpowers-V, plus an operator-shell; artifacts span PRD, tickets, plan, agent logs, evidence, and PR.

13. Concurrent development via worktrees (L4). You use isolated workspaces and branches so multiple agents/tasks don't collide; you partition file sets and merge results cleanly. KPI: at least 2 active worktrees for senior tasks (3–5 for advanced work) with 0 file collisions left undocumented. Tools: Git worktrees, branches, tmux, devcontainers, Superpowers using-git-worktrees; artifacts are a worktree map and partition report.

14. Remote mode with notifications / mobile control (L4). You start long-running agents and steer them remotely: approve, redirect, inspect output, and get notified when they're blocked or done. KPI: notifications on for tasks over 1 hour, every blocker raises an alert, and response to a blocker is within 30 minutes during work hours. Tools: Claude Remote Control, Claude mobile/web, and Notification hooks with desktop/mobile push.

Safety & ops (skill 15)

15. Configures hooks / permissions / safety gates (L4). You build deterministic guardrails: format after edit, tests before commit, block secrets, protect .env, require approval for migrations/deletes/prod commands, and audit MCP calls. KPI: 100% of repos have base gates (secret scan, protected files, pre-commit/test gate), 0 leaked secrets, and dangerous commands require approval. Tools: Claude hooks (PostToolUse, Notification, command hooks), AgentShield, .claude/settings.json, .cursor/hooks.json, branch protection, secret scanners.

Craft & universality (skill 17)

17. Result demonstration: video demo, interactive report (L4). You don't just do the work, you package and show it: record a UI video demo, assemble an interactive report, or generate a narrated overview. The demo is part of Definition of Done, in interactive form and generated via AI. KPI: every significant feature/PR ships with a demo artifact (a video under 3 minutes or an interactive report); for client features and meeting outcomes that's 100%, and the demo is generated by a skill, not by hand. Tools: claude-ui-recorder (record, narrate, render to demo.mp4), Remotion skills, NotebookLM audio overviews, Loom.

How the skills deepen by level

The same skill gets deeper as you climb. From L2 to L5:

• Code through the agent: L2 tries it and checks everything by hand → L3 runs at least 80% of routine through the agent → L4 ~90%, hand-coding only the critical parts → L5 100% of routine, setting the team norm.
• MCP: L2 one basic MCP → L3 2+ working MCP → L4 4+ MCP covering docs and repo → L5 MCP governance and policy.
• Skills / plugins: L2 installs ready-made → L3 5 active, 3 in use → L4 authors project skills → L5 runs an internal marketplace.
• Project memory: L2 reads CLAUDE.md/AGENTS.md → L3 maintains and updates it → L4 sets the repo standard → L5 sets it company-wide.
• Plan-before-code: L2 plans the big tasks → L3 plans 100% of tasks over 2h → L4 designs the workflow → L5 owns the planning templates.
• Deep research / playground: L2 on request → L3 for unfamiliar tasks → L4 research note + PoC as the norm → L5 a research platform.
• Harnesses / reusable skills: L2 not yet → L3 uses others' → L4 builds its own (3+) → L5 the harness becomes a product.
• Parallel agents: L2 one chat → L3 2–3 roles → L4 4–6 roles → L5 fleet orchestration.
• Verification harness: L2 manual checks → L3 80% of PRs with evidence → L4 90–95% of PRs, self-fixing → L5 an eval platform.
• Model routing: L2 one model → L3 2 tiers → L4 3+ routes with a cost log → L5 a routing policy and dashboard.
• Eval / acceptance loop: L2 acceptance by hand → L3 AC on every ticket → L4 5–20 evals in CI → L5 a company eval platform.
• Autonomous cycle: L2 not yet → L3 1–2 hours supervised → L4 5+ hours → L5 multi-ticket orchestration.
• Worktrees: L2 one branch → L3 1–2 worktrees → L4 3–5 in parallel → L5 a partition standard.
• Remote / notifications: L2 not yet → L3 basic alerts → L4 full remote control → L5 operator-shell mode.
• Hooks / safety gates: L2 defaults → L3 base gates → L4 a full policy → L5 company security boundaries.
• AI code review: L2 self-review → L3 independent AI review → L4 writer/reviewer/tester split → L5 the SDLC review standard.
• Result demonstration: L2 screenshot or text → L3 video demo by hand → L4 auto-demo via skill, 100% of client features → L5 a demo standard with brand templates.

The metrics that reveal your real level

A handful of numbers expose your real level faster than any self-assessment. These are what ProCoders measures and tracks over time.

Metric	L2	L3	L4	L5
% of code through the agent	tries it	≥80%	~90%, hand-coding only critical	=100% of routine
Autonomous run (longest uninterrupted run)	<30 min	1–2 h	5+ h	multi-ticket cycle
Human interventions / run	constant	frequent	≤3	supervision only
Plan / token budget (subscription the level demands)	Pro (~$20)	Max 5× (~$100)	Max 20× ($200)	Max 20× ($200) + API
Cost / time log (tracking tokens and time per task)	—	—	per PR	team/project dashboard

The logic: the higher the level, the more parallel agents, autonomous hours, and evals you run — which drives token consumption up and the plan tier with it. From L4 the norm is Max 20× ($200), because you're running several worktree agents and verification loops at once. At L5 you add cost measurement (cost log to dashboard) so spend is deliberate. (Prices and plan names change; this reflects ProCoders' current internal mapping, not an official price list.)

The behaviors above are exactly what our assessment grades. Take the free test to see which of the 17 you already own and which level you land on.

Related: the anatomy of a compound system shows how ProCoders' Compound V assembles these ideas into a real, reviewed multi-agent workflow.