You need dev skills to use AI well
AX is a superset of DX — AX without DX is a castle built on sand
Anthropic 2026 Report: developers delegate 60% but trust only 0–20% — this "Delegation Gap" is a DX problem, not an AI problem
AI generates hundreds of lines, but you can't read diffs, don't know how to branch, and can't roll back. AI code becomes an uncontrollable black box.
AI produces code that "looks like it works" — the industry calls this "Code Slop." Without a testing habit, you fall into a loop of asking AI to verify AI output. Problems surface only in production.
Tossing "fix this" back to AI makes code more complex and breaks it differently. This is the ping-pong anti-pattern.
"Build me an app" isn't a prompt — it's a prayer. Without problem decomposition skills, you can only give vague requirements and get vague results.
Martin Fowler calls context engineering the skill that separates 10x from 2x AI value. Without knowing project structure, dependencies, and constraints, you don't even know what to provide as context.
Most agentic coding tools are CLI-based. Without terminal, env vars, and package manager skills, it's not a speed bump — it's a wall.
Fortune calls it "the rise of the Supervisor Class" — three skill layers needed: Understanding · Directing · Verifying
branch, merge, resolve conflicts
Reviewing AI code diffs, isolating experiments (worktrees), instant rollback, using commit history as AI context
git diff shows exactly what changed — faster than reading AI code line by line. Commit messages and history become context that tells AI "what's happened in this project."
Unit tests, integration tests, TDD
Automated verification of AI-generated code, assertion-based validation, regression tests for AI change safety
Write tests before asking AI to generate code. When tests define expected outcomes, you can instantly judge whether AI output is correct.
PR reviews, pair programming
Critically reviewing AI-generated code, asking "why this implementation?", checking security, performance, maintainability
Accepting AI code because "it looks right" is like merging an intern's code without review. AI code demands stricter review.
Build, test, lint, deploy automation
Automated testing of AI-generated code, pre-commit hooks as quality gates, pipelining AI workflows
Without CI, you only discover AI-generated code breaks existing code after deployment. CI is AI code's automatic safety net.
README, API docs, code comments
CLAUDE.md, system prompts, structured context, prompt asset management
Past documentation was "for humans to read." Today's context engineering is "for AI to understand precisely." Best practices show effective CLAUDE.md follows: project overview → architecture principles → conventions → testing strategy → commands → anti-patterns.
Separation of concerns, layered architecture, microservices
Clear module boundaries AI can understand and modify, one file = one responsibility
AI can't handle 1,000-line God classes. It seems to understand them but breaks other parts when modifying. Sub-200-line focused modules let AI work accurately.
Shell commands, scripts, terminal workflows
MCP server setup, tool definitions, granting agents permissions and tools
Claude Code, Codex, aider — they all run in the terminal. Setting up MCP servers, defining tools, and managing agent permissions is the new "dev environment setup."
Breakpoints, logging, profiling
Identifying AI hallucinations, prompt debugging, reasoning about causes with AI (but debugging AI code yourself)
Debugging shouldn't be delegated to AI. But you can leverage AI during the process. Knowing this difference is itself a DX competency.
Docker, env vars, package managers, virtual environments
API key management, model configuration, sandbox environments, tool permission management
Using AI tools means securely managing API keys and setting up appropriate sandboxes when agents access the file system.
REST API, GraphQL, SDK design
Function calling schemas, MCP protocol, structured output definitions
To give AI tools, you need clear interface definitions. Parameter names, types, descriptions — all determine whether AI uses a tool correctly.
Senior developers who think "I lived through the DX era, so I'm fine" should pay attention too
| Area | 2020 DX | 2026 AX-Era DX |
|---|---|---|
| Documentation audience | Humans (colleagues, future self) | Humans + AI |
| Code review targets | Code written by colleagues | Code from colleagues + AI |
| Purpose of testing | Verify my code's correctness | Verify my code + AI output |
| CLI usage | Development convenience | Essential for agent operations |
| Architecture criteria | Structures humans can maintain | Structures humans + AI can understand & modify |
Learn DX while doing AX — parallel learning strategy
Apply branch workflow to AI projects. Commit every time AI generates code, read diffs, create branches. Convert one GUI task to terminal.
Execute test-first → AI-implement pattern 3+ times. If your project lacks pre-commit hooks, set up at minimum lint + type check.
Write CLAUDE.md for your main project (target under 1,500 tokens). Organizing context for AI is simultaneously the process of understanding your project.
Pick your largest file and split-refactor it with AI. Apply review checklist before accepting AI code: why this approach, security vulnerabilities, edge cases.
1 point each. Be honest.
git diff and evaluate AI code changes