# AI Developer Toolkit

> Agentic engineering with Cursor, Claude Code and Codex: find which level of the autonomy ladder (0–5) your workflow is at and move up one. 400+ guides on setup, the harness (CLAUDE.md, AGENTS.md, rules, MCP), loops, verification and release.

AI Developer Toolkit (developertoolkit.ai) is a learning platform for professional developers, sold as a one-time purchase for 12 months of access, with no subscription. Content is bilingual (English and Polish) and organized by tool and by level of the autonomy ladder — the /start/ and /ladder/ sections are free, no account required.

## Product and author

- [Pricing](https://developertoolkit.ai/en/pricing/): The Toolkit is $59.99 once: the Setup Pack for your stack, 12 months of 400+ guides and all eight books. Nothing renews on its own. 30-day refund on a first purchase.
- [For teams](https://developertoolkit.ai/en/services/): Up to 8 developers, one repository, one tool. The agent config, task template, test expectations and review checklist stay in your repo.
- [Setup Pack](https://developertoolkit.ai/en/setup-pack/): Nine questions, then your CLAUDE.md, AGENTS.md, Cursor rules, MCP config and TESTING.md — the Level 2 to 3 move, generated for your stack, installed in about 20 minutes.
- [Books](https://developertoolkit.ai/en/books/): All eight books ($383 at the median price of comparable ebooks): the Handbook, a book each on Cursor, Claude Code and Codex, and four role paths. In the Toolkit.
- [Examples](https://developertoolkit.ai/en/examples/): One walkthrough of the artifact chain, then the recipes: frontend, backend, databases, DevOps and mobile.
- [Contents](https://developertoolkit.ai/en/contents/): All 400+ guides in one list: Cursor, Claude Code, Codex, the Ladder, MCP, Skills, workflows and the cookbook.
- [About](https://developertoolkit.ai/en/about/): Who writes AI Developer Toolkit and why: the ladder from AI autocomplete to a software factory, in Claude Code, Codex and Cursor — by a CTO who ships with agents.
- [Developer Scorecard](https://developertoolkit.ai/en/scorecard/): A free 25-question scorecard that places you on the autonomy ladder, Level 1 to 4 — and names the one move that takes your workflow up a rung.
- [Tech Lead Scorecard](https://developertoolkit.ai/en/lead-scorecard/): A free 25-question scorecard for tech leads: the level your whole team ships at, across six dimensions — plus a 30/60/90 plan that moves it up a rung.
- [C-Level Scorecard](https://developertoolkit.ai/en/cto-scorecard/): A free 25-question scorecard on your org’s level — adoption and spend, shared infrastructure, quality gates, parallelism, ROI — with a 30/60/90 plan and a risk register.
- [MCP](https://developertoolkit.ai/en/mcp/): A public Model Context Protocol endpoint over 1100+ guides on Cursor, Claude Code and Codex. Two tools: search and fetch.
- [What's New](https://developertoolkit.ai/en/whats-new/): Level 5 of the autonomy ladder, the state of agentic engineering in 2026, compound engineering audited, and the anti-slop skills — each with the job it is for.
- [Community](https://developertoolkit.ai/en/community/): A Discord for questions about the guides, and a public GitHub repository where you can report a mistake.
- [Contact](https://developertoolkit.ai/en/contact/): Questions, technical help and team enquiries. Warsaw, Poland — support@developertoolkit.ai

## Autonomy Ladder (free, no account required)

- [The Autonomy Ladder: Which Level Is Your Workflow At?](https://developertoolkit.ai/en/ladder/): Dan Shapiro's six-level scale for how much code agents write and humans read, a test to place each loop on it, and the guide for every rung.
- [Your craft and career when agents write the code](https://developertoolkit.ai/en/ladder/craft-and-career/): Which engineering skills compound and which erode when agents write the code, the paradox of supervision, and a portfolio plan for each ladder level.
- [Reading evidence instead of code](https://developertoolkit.ai/en/ladder/evidence-not-diffs/): What to read instead of an agent's diff: spec delta, acceptance results, oracle strength and runtime signals, plus the changes where a human still reads code.
- [Level 1–2: Assisted and Paired Coding](https://developertoolkit.ai/en/ladder/level-1-2-assisted-paired/): Autonomy ladder Levels 1 and 2: how to tell you are at Level 2 and the three-part setup per tool (context file, plan gate, verified loop) that moves a repo up.
- [Level 3: You Review the Diffs](https://developertoolkit.ai/en/ladder/level-3-review-diffs/): Level 3 of the autonomy ladder: agents write in parallel and you review every diff. How to run it, why review bandwidth caps it, and how to move to evidence.
- [Level 4: You Write the Specs](https://developertoolkit.ai/en/ladder/level-4-write-specs/): Level 4 of the autonomy ladder: you write the spec, the stop condition and the oracle, then the agent runs for hours. Setup for Claude Code, Codex and Cursor.
- [Level 5: You Run the Software Factory](https://developertoolkit.ai/en/ladder/level-5-run-the-factory/): Level 5 of the autonomy ladder: six factory stations mapped to Claude Code, Codex and Cursor, and the test for which loops may run unattended.
- [One map: the autonomy ladder, the lifecycle and the factory stations](https://developertoolkit.ai/en/ladder/one-map/): One grid for the autonomy ladder (L0–L5 per loop), the six lifecycle stages and the six factory stations, with the evidence each cell requires.
- [The State of Agentic Engineering, September 2026](https://developertoolkit.ai/en/ladder/state-of-agentic-engineering-2026/): How much code agents write in 2026, where the autonomy ladder tops out, and why verification is the limit. Third-party evidence only, every number dated.
- [The Human's Job in Agentic Engineering](https://developertoolkit.ai/en/ladder/the-humans-job/): Six decisions that stay human when agents write the code, how to record who owns each loop, and how to prove those decisions still hold.
- [Vibe Coding vs Agentic Engineering: 21 Terms Compared](https://developertoolkit.ai/en/ladder/vibe-coding-vs-agentic-engineering/): 21 AI-development terms set against vibe coding: who named each and when, who writes the code, who checks it, and how it differs. Every quote dated and linked.

## Start here (free, no account required)

- [Start here: pick your path through agentic engineering](https://developertoolkit.ai/en/start/): Where to start on AI Developer Toolkit: jump to the Cursor, Claude Code, or Codex quick start, or pick the reading path for your role.
- [CTO and VP Engineering track: an operating model for agent-built software](https://developertoolkit.ai/en/start/cto/): The CTO reading path for agent-built software: ten decisions in order, from evidence and a pilot to autonomy, security, spend, regulation and the board.
- [Developer track: a reading path to agentic engineering](https://developertoolkit.ai/en/start/developer/): The developer reading path: from the autonomy ladder and your tool's quick start to specs, feedback loops and reviewing evidence instead of diffs.
- [Executive track: the ten-minute brief and the five decisions you own](https://developertoolkit.ai/en/start/executive/): For executives: what coding agents change for cost, speed, and risk, the dated evidence both ways, and the five decisions leadership owns.
- [Power-user tips for Cursor, Claude Code and Codex](https://developertoolkit.ai/en/start/power-user-tips/): The highest-value tricks for Claude Code, Codex and Cursor, one line each, dated 2026-09-26 and linked to the per-tool page that explains each one.
- [Quick Wins in Your First 24 Hours](https://developertoolkit.ai/en/start/quick-wins/): Ten first-day techniques for Claude Code, Codex and Cursor, each with a copy-paste prompt and a check that proves the result without reading every line.
- [Tech lead track: move the whole team up one rung](https://developertoolkit.ai/en/start/tech-lead/): The tech lead reading path: standardize the team's agent harness, own verification design, and run review capacity, one scorecard question at a time
- [Why AI Coding Tools? From Autocomplete to Agentic Engineering](https://developertoolkit.ai/en/start/why-ai-coding-tools/): Why AI coding tools changed the job: agents write the code, so the work moves to specifying behavior and proving it with checks. Agentic engineering explained.

## Cursor

- [Cursor IDE: The AI Code Editor](https://developertoolkit.ai/en/cursor-ide/): Start here for Cursor: which surface fits which task, how a change moves from plan to merged pull request, and how to prove it works without reading every diff.
- [Cursor automation: pick the surface, then prove the result](https://developertoolkit.ai/en/cursor-ide/automate/): Automate Cursor with rules, custom MCP servers, the CLI in CI, Cloud Agents with Automations, and the SDK, and verify every run without reading each diff.
- [Advanced Cursor techniques: tips 91-105](https://developertoolkit.ai/en/cursor-ide/automate/advanced-techniques/): Fifteen advanced Cursor tips: MCP with least privilege, Cloud Agent specs, a stop hook that runs your gates, layered review, and model and token discipline.
- [Scripting the Cursor CLI: git hooks, CI review and scheduled jobs](https://developertoolkit.ai/en/cursor-ide/automate/automation-workflows/): Run Cursor's headless agent (agent -p) in a pre-commit hook, a GitHub Actions PR review and a weekly job, with deterministic gates that prove the output.
- [Cloud Agents and Automations: Cursor's Factory Floor](https://developertoolkit.ai/en/cursor-ide/automate/cloud-agents-automations/): Run Cursor cloud agents unattended with Automations: pick a trigger, scope tools and repos, verify the PRs they open, and handle the failures that cost money.
- [The Cursor SDK and the Cloud Agents API](https://developertoolkit.ai/en/cursor-ide/automate/cursor-sdk/): Launch and follow Cursor cloud agents from scripts and CI with @cursor/sdk 1.0.32 and the Cloud Agents API, plus a workflow that opens a PR when main fails.
- [Build a custom MCP server with Cursor's agent](https://developertoolkit.ai/en/cursor-ide/automate/custom-mcp-servers/): Have Cursor's agent build a read-only Postgres MCP server on the v2 TypeScript SDK, prove it with Inspector and tests, then register it in mcp.json.
- [Custom rules and templates in Cursor](https://developertoolkit.ai/en/cursor-ide/automate/custom-rules-templates/): Grow .cursor/rules/ into a tested library: pick the right load mode, template real workflows, share it through Team Rules or plugins, and prove it loads.
- [Build with Cursor: from agent chat to verified change](https://developertoolkit.ai/en/cursor-ide/build/): 22 Cursor build guides for developers and tech leads: editor features, agent chats, parallel agents and real scenarios, each ending in proof.
- [Agent chat workflows in Cursor](https://developertoolkit.ai/en/cursor-ide/build/agent-chat/): Run Cursor's agent chat from request to proven change: tests as the definition of done, gates in the prompt, evidence reports, and when to restart.
- [Cursor agent modes: when to plan, ask, build and debug](https://developertoolkit.ai/en/cursor-ide/build/agent-modes-deep-dive/): Pick the right Cursor agent mode for each phase: Plan Mode before edits, Agent mode against gates, and read-only or debug passes when you need evidence.
- [The Agents Window in Cursor: running parallel agents](https://developertoolkit.ai/en/cursor-ide/build/agents-window/): Run several Cursor agents in parallel from the Agents Window, give each an isolated checkout and a task card, and merge only what carries its own evidence.
- [Building API integrations with Cursor's agent](https://developertoolkit.ai/en/cursor-ide/build/api-integration/): Build Stripe, SendGrid and Twilio integrations with Cursor's agent: tests first, retries, idempotency, signed webhooks, and gates that prove it works.
- [Checkpoints and branching: undo Cursor agent changes safely](https://developertoolkit.ai/en/cursor-ide/build/checkpoints-branching/): Pair Cursor checkpoints with Git branches and commits so you can undo one agent turn, one file or a whole experiment, and keep only verified changes.
- [Cursor core features: pick the right tool and verify the result](https://developertoolkit.ai/en/cursor-ide/build/core-features/): 15 Cursor daily-driver features (Tab, inline edit, agent modes, @ context, checkpoints, Bugbot), each paired with the check that proves its output.
- [Build a data pipeline with Cursor](https://developertoolkit.ai/en/cursor-ide/build/data-pipeline/): Build an ETL pipeline with Cursor Agent: Plan Mode contract, fixture tests guarded against Agent edits, idempotent loads, and reconciliation proving the data.
- [Generate and verify documentation with Cursor's agent](https://developertoolkit.ai/en/cursor-ide/build/documentation/): Have Cursor's agent write TSDoc, guides, Mermaid diagrams and migration notes from your code, then prove them in CI instead of proofreading.
- [Build frontend UI from designs with Cursor](https://developertoolkit.ai/en/cursor-ide/build/frontend-ui/): Turn Figma frames into React components with Cursor's agent, pin your design tokens in a rule, and prove the match with Playwright screenshots and axe.
- [Cursor inline edit: tips 46–60](https://developertoolkit.ai/en/cursor-ide/build/inline-edit/): Scope Cursor's inline edit with the selection, write instructions that land first time, chain small edits, and prove each one with types and tests.
- [Large codebase strategies in Cursor](https://developertoolkit.ai/en/cursor-ide/build/large-codebase-strategies/): Keep Cursor's agent accurate in a large repo or monorepo: open one package, filter noise, scope rules, plan cross-package changes, and verify with gates.
- [Refactoring legacy code with Cursor](https://developertoolkit.ai/en/cursor-ide/build/legacy-refactor/): Refactor an untested legacy codebase with Cursor's agent: pin behaviour with characterization tests, change one seam per commit, and prove nothing moved.
- [Microservices development in Cursor](https://developertoolkit.ai/en/cursor-ide/build/microservices/): Build microservices with Cursor Agent: topology rules, Plan Mode boundaries, contract-first APIs gated by lint and breaking-change checks, exemplar scaffolds.
- [Framework migration in Cursor](https://developertoolkit.ai/en/cursor-ide/build/migration/): Migrate frameworks and major versions in Cursor: inventory in Plan Mode, codemods first, agent batches with locked tests, and a CI ratchet on old patterns.
- [Mobile app development with Cursor](https://developertoolkit.ai/en/cursor-ide/build/mobile-dev/): Build React Native screens with Cursor's agent: a scoped mobile rule, simulator MCP servers, and gates plus both-platform screenshots that prove each change.
- [Multi-repo workflows in Cursor](https://developertoolkit.ai/en/cursor-ide/build/multi-repo-workflows/): Work across several repositories in Cursor: multi-root workspaces, ownership rules, read-only GitHub MCP, and contract-first changes gated in every repo's CI.
- [Pair programming with Cursor's agent](https://developertoolkit.ai/en/cursor-ide/build/pair-programming/): Pair with Cursor's agent on one feature: agree the design in Plan Mode, build test-first slices, debug from evidence, and verify each step by command.
- [Prompt templates for Cursor's agent](https://developertoolkit.ai/en/cursor-ide/build/prompt-templates/): Copy-paste Cursor prompt templates for features, bugs, refactors, tests and review, each with a verification step, stored as Agent Skills or project rules.
- [Refactoring strategies in Cursor](https://developertoolkit.ai/en/cursor-ide/build/refactoring-strategies/): Split, rename and restructure tested code with Cursor's agent one small step at a time, with gates that prove behaviour did not change.
- [Snippet management in Cursor](https://developertoolkit.ai/en/cursor-ide/build/snippet-management/): Split Cursor boilerplate between VS Code snippets, scoped rules and agent prompts, and gate it in CI so the scaffolds compile and never drift from your code.
- [Cursor Tab: get multi-line edits right and verify them](https://developertoolkit.ai/en/cursor-ide/build/tab-autocomplete/): Get reliable multi-line edits from Cursor Tab: seed the pattern, accept or reject fast, and let types, tests and lint check what you accepted.
- [Cursor time savers for everyday chores](https://developertoolkit.ai/en/cursor-ide/build/time-savers/): Hand Cursor the recurring chores (docs comments, commit messages, bulk edits, missing tests, pre-push fixes), each paired with a gate that checks the result.
- [Operate Cursor in production](https://developertoolkit.ai/en/cursor-ide/operate/): Which Cursor operate guide to open for token spend, a slow editor, slow code, missing observability or a security audit, and how to prove each fix worked.
- [Logging and monitoring setup in Cursor](https://developertoolkit.ai/en/cursor-ide/operate/monitoring/): Use Cursor's agent to generate structured logs, Prometheus metrics, OpenTelemetry tracing and alert rules, then prove each layer works with tests and promtool.
- [Tune Cursor for large codebases](https://developertoolkit.ai/en/cursor-ide/operate/performance-optimization/): Make Cursor fast on a large repo: trim the index with .cursorignore, audit extensions, cap watchers and search, and prove each change with before/after numbers.
- [Application performance optimization with Cursor](https://developertoolkit.ai/en/cursor-ide/operate/performance/): Measure first, let Cursor's agent fix N+1 queries, bundle weight and re-renders, then prove each win with a rerun baseline, unchanged tests and a CI budget.
- [Security audit workflow in Cursor](https://developertoolkit.ai/en/cursor-ide/operate/security/): Audit a codebase for security bugs with Cursor: scanners first, agent review second, a failing exploit test for every finding, and CI gates that keep it fixed.
- [Token management in Cursor](https://developertoolkit.ai/en/cursor-ide/operate/token-management/): Cut Cursor token spend without losing quality: scope rules, keep chats short, attach less, and prove each saving with SDK usage data and a compaction log.
- [Plan with Cursor: an accepted plan before any code](https://developertoolkit.ai/en/cursor-ide/plan/): Three Cursor guides for developers and tech leads: start a project, design a database schema, and choose an architecture in Plan Mode before any edit.
- [Designing system architecture with Cursor's agent](https://developertoolkit.ai/en/cursor-ide/plan/architecture/): Research options in Cursor's Plan Mode, record the decision as an ADR, then enforce it with a project rule and CI fitness checks instead of reading every diff.
- [Database schema design with Cursor](https://developertoolkit.ai/en/cursor-ide/plan/database-design/): Design a Postgres schema with Cursor's agent: agree the model first, generate Drizzle, then prove rules, query plans and migrations with tests.
- [Start a new project with Cursor's agent](https://developertoolkit.ai/en/cursor-ide/plan/new-project/): Take a one-line brief to a running Next.js scaffold in Cursor: PRD in Plan Mode, project rules first, gates proven to fail, then a first test-backed feature.
- [Cursor quick start: from install to a verified first feature](https://developertoolkit.ai/en/cursor-ide/quick-start/): The Cursor quick start: install, a verify command, run modes, project rules, MCP and Plan Mode, then a first feature proved by tests, not by reading the diff.
- [Version control and team collaboration in Cursor](https://developertoolkit.ai/en/cursor-ide/quick-start/collaboration/): Use Cursor's agent for commit messages, merge conflicts, pull requests and PR review, with git checks that prove nothing was lost before you push.
- [Context management in Cursor](https://developertoolkit.ai/en/cursor-ide/quick-start/context-management/): Give Cursor's agent the right context: @-mention one canonical example, fence the change, add current docs, hand off between chats, and prove what it used.
- [Debugging and Error Recovery](https://developertoolkit.ai/en/cursor-ide/quick-start/error-handling/): Recover when Cursor's agent breaks your code: roll back with checkpoints or git, stop fix loops, decide to fix forward or restart, and prove the result.
- [Essential Cursor configuration for agent work](https://developertoolkit.ai/en/cursor-ide/quick-start/essential-configuration/): Set Cursor up so the agent runs your checks unattended: a verify command, a run mode, project rules, a stop hook that re-runs the gate, and .cursorignore.
- [Build your first AI-assisted feature](https://developertoolkit.ai/en/cursor-ide/quick-start/first-feature/): Build a multi-file feature with Cursor's agent: acceptance criteria, Plan Mode, scoped build steps, and proof it works without reading every line.
- [Install Cursor and migrate from VS Code](https://developertoolkit.ai/en/cursor-ide/quick-start/installation-setup/): Install Cursor on macOS, Windows, or Linux with a package manager, carry over your VS Code setup, and prove the agent sees your real project.
- [Set up MCP servers in Cursor](https://developertoolkit.ai/en/cursor-ide/quick-start/mcp-setup/): Connect Cursor's agent to GitHub, Postgres and a browser through .cursor/mcp.json, keep tokens out of git, and prove every answer came from a real tool call.
- [Model selection in Cursor](https://developertoolkit.ai/en/cursor-ide/quick-start/model-selection/): Pick a Cursor model per task: start on one strong default, tune its effort variant first, and switch only when a benchmark on your own tests says so.
- [Turn a PRD into a plan and tasks in Cursor](https://developertoolkit.ai/en/cursor-ide/quick-start/prd-workflow/): Turn a PRD into numbered acceptance criteria, a Plan Mode plan committed as plan.md, and one verified task per chat in Cursor.
- [Project rules in Cursor](https://developertoolkit.ai/en/cursor-ide/quick-start/project-rules/): Write your first Cursor project rules in .cursor/rules/, pick the right load mode for each, and prove with a canary and a probe task that Agent follows them.
- [Staying current with Cursor](https://developertoolkit.ai/en/cursor-ide/reference/): Know which Cursor build and SDK each machine runs, read releases against your committed config, and roll updates out behind canary tests.
- [Cursor version history](https://developertoolkit.ai/en/cursor-ide/reference/changelog/): Cursor release milestones to October 2026: the current version and its numbering, changelog entries since August, renamed features, and a routine that turns a release note into a team rollout.
- [Adopting new Cursor features](https://developertoolkit.ai/en/cursor-ide/reference/feature-adoption/): Sort each new Cursor feature by blast radius, trial it in a worktree against merged tickets, prove it with CI gates, then commit it to the repo.
- [Cursor Keyboard Shortcuts: Confirm, Pin and Chain](https://developertoolkit.ai/en/cursor-ide/reference/keyboard-shortcuts/): Confirm Cursor's AI shortcuts in your own build, pin them in keybindings.json so updates cannot move them, and chain them into checked workflows.
- [Cursor upgrade guides](https://developertoolkit.ai/en/cursor-ide/reference/upgrade-guides/): Update Cursor without losing a working setup, prove the new build against a recorded baseline, and roll back to a hash-checked previous build.
- [Review and ship with Cursor](https://developertoolkit.ai/en/cursor-ide/ship/): Take a Cursor-written change from diff to production: pre-push review, Bugbot, CI gates, rule-based approval and a rollout you can undo.
- [Bugbot: learned rules and Autofix](https://developertoolkit.ai/en/cursor-ide/ship/bugbot/): Set up Cursor's Bugbot, teach it rules from your review history, decide how far Autofix may go, and prove the review layer catches real bugs.
- [CI/CD pipelines with Cursor](https://developertoolkit.ai/en/cursor-ide/ship/ci-cd/): Generate and debug GitHub Actions pipelines with Cursor, run a read-only Cursor SDK agent in CI, and prove every workflow with actionlint, zizmor and a red run.
- [Code review in Cursor: local review, PR triage and a CLI reviewer](https://developertoolkit.ai/en/cursor-ide/ship/code-review/): Review code in Cursor without reading every line: Agent Review and /review-bugbot before push, triage prompts for pull requests, and a read-only CLI reviewer.
- [Infrastructure as code with Cursor](https://developertoolkit.ai/en/cursor-ide/ship/devops/): Generate Terraform, Dockerfiles and Kubernetes manifests with Cursor's Agent, ground it in read-only MCP, and prove each change with checkov and a plan summary.
- [Rollouts and PR Routing & Approval in Cursor](https://developertoolkit.ai/en/cursor-ide/ship/rollouts-and-approval/): Let Cursor approve low-risk pull requests by rule: CI-computed risk classes, a GitHub ruleset that owns the merge, an audit trail, and a rollout safety net.
- [Cursor for teams and enterprises](https://developertoolkit.ai/en/cursor-ide/team/): Roll Cursor out to a team in the right order: data flow, vendor questions, shared repo config, a pre-review gate and Cloud Agents, with proof each step holds.
- [Privacy and security in Cursor](https://developertoolkit.ai/en/cursor-ide/team/privacy-security/): Lock down Cursor for a team: Privacy Mode, .cursorignore, run modes, a hooks-based guard, MCP approval, and a test that proves the controls still work.
- [Team collaboration in Cursor](https://developertoolkit.ai/en/cursor-ide/team/team-collaboration/): Commit Cursor rules, MCP config and skills to the repo, gate agent output in CI and Bugbot, and onboard a developer so their agent matches the team's.
- [Test and debug with Cursor](https://developertoolkit.ai/en/cursor-ide/test/): Get tests from Cursor's agent that catch real bugs, and fix failures without the fix-break-fix loop: the three Cursor testing and debugging guides.
- [AI-Assisted Debugging in Cursor](https://developertoolkit.ai/en/cursor-ide/test/bug-hunting/): Find intermittent failures and race conditions in Cursor: investigate read-only, reproduce with a failing test, fix one cause, and prove it with evidence.
- [Testing patterns in Cursor](https://developertoolkit.ai/en/cursor-ide/test/testing-patterns/): Prompts that get Cursor's agent to write tests that catch real bugs in existing code: behaviour-first suites, characterization tests, E2E and flaky tests.
- [Test-driven development in Cursor](https://developertoolkit.ai/en/cursor-ide/test/testing-tdd/): Run TDD with Cursor's agent: you approve failing tests as the spec, the agent implements until green without touching them, and mutation tests prove the suite.

## Claude Code

- [Claude Code](https://developertoolkit.ai/en/claude-code/): Claude Code for developers and tech leads: ship a first verified change, pick a permission mode, prove the output, and find the right guide.
- [Claude Code automation: pick the surface, then prove the result](https://developertoolkit.ai/en/claude-code/automate/): Run Claude Code unattended with /goal, claude -p, hooks, background agents, workflows, routines or the Agent SDK, and prove each run with machine gates.
- [Advanced Claude Code techniques](https://developertoolkit.ai/en/claude-code/automate/advanced-techniques/): Tune effort instead of prompt wording, load MCP servers on the first try, ship a custom MCP tool, review every PR in CI, and run tasks in isolated worktrees.
- [The Claude Agent SDK: building your own agents on Claude Code's loop](https://developertoolkit.ai/en/claude-code/automate/agent-sdk/): Drive Claude Code's agent loop from Python or TypeScript: tools, permissions, hooks, subagents, MCP and sessions, with a verified CI triage bot as the example.
- [Agent view: run many Claude Code sessions with claude agents](https://developertoolkit.ai/en/claude-code/automate/agent-view/): Dispatch, watch and verify parallel Claude Code background sessions from the claude agents dashboard, with worktree isolation and evidence-first review.
- [Scripting Claude Code: Headless Runs, Pipes, Cron and Git Hooks](https://developertoolkit.ai/en/claude-code/automate/automation/): Run Claude Code unattended with claude -p: scoped permissions, JSON output your script checks, pipes, skills, pre-commit gates, cron jobs and cost caps.
- [Channels and Remote Control: driving Claude Code sessions from anywhere](https://developertoolkit.ai/en/claude-code/automate/channels-and-remote-control/): Steer a local Claude Code session from a phone with Remote Control, push CI and chat events into it with channels, and know when a cloud run fits better.
- [Custom commands and skills in Claude Code](https://developertoolkit.ai/en/claude-code/automate/custom-commands/): Turn your team's checks into Claude Code slash commands: skill files, arguments, who may trigger them, precedence, a CI lint, and how to prove they work.
- [Custom subagents in Claude Code: scoped specialists you can verify](https://developertoolkit.ai/en/claude-code/automate/custom-subagents/): Define Claude Code subagents in .claude/agents/, scope their tools and models, run them in parallel worktrees, lint them in CI and verify what they report.
- [Dynamic workflows and ultracode](https://developertoolkit.ai/en/claude-code/automate/dynamic-workflows/): Run codebase audits, migrations and cross-checked research as one Claude Code workflow script that fans out many subagents, verifies their findings and reruns.
- [Goal workflows with /goal in Claude Code](https://developertoolkit.ai/en/claude-code/automate/goal-workflows/): Give Claude Code a finish line with /goal: write conditions the evaluator can judge, run goals unattended, and prove the result without reading every diff.
- [Claude Code hooks: guardrails, gates, and live context](https://developertoolkit.ai/en/claude-code/automate/hooks-automation/): Claude Code hooks that block risky commands, protect paths, lint every edit, and refuse to stop on red tests, with fixture tests that prove each one works.
- [Routines: Scheduled, API and GitHub-Triggered Claude Code Runs](https://developertoolkit.ai/en/claude-code/automate/routines/): Run Claude Code unattended in the cloud on a schedule, an API call or a GitHub event: triggers, the claude/ branch rule, the fire payload, and how to verify runs.
- [Build with Claude Code: from an approved plan to a proved change](https://developertoolkit.ai/en/claude-code/build/): Claude Code build guides for developers and tech leads: implement an approved plan in slices, run large changes, and prove each change with gates.
- [Build REST and GraphQL APIs with Claude Code](https://developertoolkit.ai/en/claude-code/build/api-development/): Build REST and GraphQL APIs with Claude Code: contract in plan mode, one resource per slice, and spec, fuzz and auth gates that prove it works.
- [Batch operations: one change across hundreds of files](https://developertoolkit.ai/en/claude-code/build/batch-operations/): Apply one change across hundreds of files with Claude Code: plan first, fan out with /batch or claude -p scripts, and prove the result with gates.
- [Claude Code command line: sessions, flags and one-shot pipes](https://developertoolkit.ai/en/claude-code/build/command-line/): Resume and name Claude Code sessions, set model, effort, and permission mode per launch, and pipe one-shot claude -p runs with output you can check.
- [Database work in Claude Code: schemas, migrations, queries and seed data](https://developertoolkit.ai/en/claude-code/build/database-work/): Design schemas, draft migration files, tune queries and seed test data with Claude Code, and prove each change on a disposable database before CI applies it.
- [Claude Code Desktop: sessions, worktrees and review in the app](https://developertoolkit.ai/en/claude-code/build/desktop-app/): What the Claude Code Desktop app adds over the CLI: parallel worktree sessions, diff review, app preview and CI monitoring, and which settings both share.
- [Generate and maintain documentation with Claude Code](https://developertoolkit.ai/en/claude-code/build/documentation/): Generate JSDoc, OpenAPI, READMEs and architecture docs from code with Claude Code, then keep them true with hooks, lint gates and a headless drift check.
- [Efficiency hacks for daily Claude Code work](https://developertoolkit.ai/en/claude-code/build/efficiency-hacks/): Claude Code habits that save time without skipping checks: one task per session, scoped reads, skills for repeated prompts, JSON output and a kept test gate.
- [What Claude Code Can Do That You Haven't Tried](https://developertoolkit.ai/en/claude-code/build/features-you-havent-tried/): About 30 underused Claude Code features, from CLAUDE.md imports and secret denies to /btw, /goal, /verify and hooks: what each fixes and how to check it.
- [IDE and CLI coordination: run Claude Code beside your editor](https://developertoolkit.ai/en/claude-code/build/ide-coordination/): Run the Claude Code CLI beside VS Code, Cursor, JetBrains, or Neovim: split layouts, one writer per file, worktrees, and editor-side checks.
- [From plan to working code with Claude Code](https://developertoolkit.ai/en/claude-code/build/implementation/): Turn an approved plan into committed code with Claude Code: commit-sized slices, hook-enforced gates, evidence per slice and clean resumes across sessions.
- [Build third-party API integrations with Claude Code](https://developertoolkit.ai/en/claude-code/build/integrations/): Build Stripe, email, OAuth and webhook integrations with Claude Code, then prove them with replayed events, signature tests and duplicate-delivery checks.
- [Large codebases and monorepos in Claude Code: scope, plan, verify](https://developertoolkit.ai/en/claude-code/build/large-codebase/): Scope Claude Code to the slice of a large repo or monorepo a task touches, plan cross-package changes, isolate parallel work, and verify with gates.
- [Claude Code memory: CLAUDE.md, rules and auto memory](https://developertoolkit.ai/en/claude-code/build/memory-system/): Set up CLAUDE.md, path-scoped rules, imports and auto memory in Claude Code, prove each file loads and is obeyed, and keep them short as the repo changes.
- [Database and code migrations with Claude Code](https://developertoolkit.ai/en/claude-code/build/migrations/): Run zero-downtime schema changes, framework upgrades and API version moves with Claude Code, phase by phase, each proven by a gate before the next ships.
- [Multi-file workflows](https://developertoolkit.ai/en/claude-code/build/multi-file-workflows/): Drive a Claude Code change across dozens of files - plan the blast radius, set acceptance checks, fan out with /batch or worktrees, and verify the diff.
- [Prompt engineering for Claude Code](https://developertoolkit.ai/en/claude-code/build/prompt-engineering/): Write Claude Code prompts that verify themselves: a four-part brief, a done-when clause, context priming, plan mode, and effort, with fixes when prompts fail.
- [Refactoring patterns in Claude Code](https://developertoolkit.ai/en/claude-code/build/refactoring-patterns/): Refactor one module with Claude Code under locked tests: Extract Function, polymorphism, service splits and async/await, each proven by gates, not by reading.
- [Large-scale refactoring with Claude Code: change structure, prove behaviour](https://developertoolkit.ai/en/claude-code/build/refactoring/): Restructure hundreds of files with Claude Code: pin behaviour first, encode the target as a rule, gate every stop with a hook, and prove nothing changed.
- [Claude Code slash commands and shortcuts, by job](https://developertoolkit.ai/en/claude-code/build/slash-commands-mastery/): The Claude Code slash commands and shortcuts worth knowing, grouped by job: context, branching, model, review, and background work, with their traps.
- [Terminal setup for Claude Code: tmux, notifications and shell pipes](https://developertoolkit.ai/en/claude-code/build/terminal-mastery/): Run Claude Code in a tmux layout beside live test and type-check panes, get notified only when it needs you, and pipe failures into read-only claude -p runs.
- [Claude Code workflow optimization: queue, remember, codify, verify](https://developertoolkit.ai/en/claude-code/build/workflow-optimization/): Run a working day from Claude Code: steer turns with the message queue, keep context across sessions, codify repeated flows as skills, and prove each change.
- [Operate Claude Code in production](https://developertoolkit.ai/en/claude-code/operate/): Run Claude Code day to day: track spend with /usage and OpenTelemetry, keep sessions healthy, profile what it ships, and audit its security.
- [Claude Code Cost Control for Teams](https://developertoolkit.ai/en/claude-code/operate/cost-control/): See, attribute and cap Claude Code spend across a team with /usage, OpenTelemetry, spend limits, budget flags and a model-and-effort policy.
- [Observability setup with Claude Code](https://developertoolkit.ai/en/claude-code/operate/monitoring/): Have Claude Code add OpenTelemetry, structured logs, tested alerts and dashboards to a live service, with hooks and a verifier subagent proving every change.
- [Claude Code performance optimization: context, cache and effort](https://developertoolkit.ai/en/claude-code/operate/performance-optimization/): Cut Claude Code token spend and latency per session: scope context, keep the prompt cache warm, tune effort before model, and prove quality held.
- [Application performance analysis with Claude Code](https://developertoolkit.ai/en/claude-code/operate/performance/): Find why your app got slow with Claude Code: baseline first, profile instead of guessing, fix one hotspot, and let a benchmark budget prove the win.
- [Security audits with Claude Code](https://developertoolkit.ai/en/claude-code/operate/security-audit/): Audit a codebase with Claude Code: deterministic scanners first, the Claude Security plugin and /security-review, exploit tests as proof, and gates that hold.
- [Troubleshoot a Claude Code session](https://developertoolkit.ai/en/claude-code/operate/troubleshooting/): Fix a Claude Code session: permission rules that don't apply, an ignored CLAUDE.md, dead MCP servers, drifting context, over-built diffs, and proof of the fix.
- [Plan with Claude Code: an approved plan before any code](https://developertoolkit.ai/en/claude-code/plan/): Four Claude Code guides for developers and tech leads: map a codebase, design a feature, choose an architecture, and start a project in plan mode.
- [Architecture analysis and system design with Claude Code](https://developertoolkit.ai/en/claude-code/plan/architecture/): Map dependencies, compare designs against your own code, write ADRs and plan migrations in Claude Code plan mode, with each claim checked by a tool.
- [Understanding an unfamiliar codebase with Claude Code](https://developertoolkit.ai/en/claude-code/plan/codebase-analysis/): Map an unfamiliar repository with Claude Code in plan mode and subagents, then prove the map with checked citations and a passing test before you change code.
- [Feature planning in Claude Code: from a one-line request to a verified plan](https://developertoolkit.ai/en/claude-code/plan/feature-planning/): Turn a vague feature request into acceptance criteria and a phased, verifiable plan with Claude Code plan mode, an interview, and a fresh-session plan audit.
- [Start a new project from the terminal with Claude Code](https://developertoolkit.ai/en/claude-code/plan/project-init/): Bootstrap a new service with Claude Code: plan the scaffold, generate it, and prove it runs with one verify script, a Stop hook and a CLAUDE.md.
- [Claude Code quick start: from install to a verified first feature](https://developertoolkit.ai/en/claude-code/quick-start/): The Claude Code quick start for developers: install, sign in, set permissions, write CLAUDE.md, and ship a first feature that tests and review prove.
- [Claude Code authentication: subscriptions, API keys, and cloud providers](https://developertoolkit.ai/en/claude-code/quick-start/authentication/): Log in to Claude Code with a Claude plan, a Console account, a cloud provider, or a CI token, and prove which credential is paying with /status.
- [Configure Claude Code: settings, permissions, and models](https://developertoolkit.ai/en/claude-code/quick-start/configuration/): Set up Claude Code settings files, permission rules and modes, the sandbox, model, and effort, then prove the result with /status and /permissions.
- [Deep reasoning in Claude Code: effort levels and extended thinking](https://developertoolkit.ai/en/claude-code/quick-start/deep-reasoning/): Tune how hard Claude Code thinks: effort levels, ultrathink, ultracode, and plan mode, with prompts, verification gates, and fixes for when deeper isn't better.
- [Build your first feature with Claude Code](https://developertoolkit.ai/en/claude-code/quick-start/development-workflow/): Take one real feature from ticket to commit with Claude Code: acceptance criteria, plan mode, tests first, gated slices, and a fresh-context review.
- [Error recovery in Claude Code: rewind, reset, and get unstuck](https://developertoolkit.ai/en/claude-code/quick-start/error-recovery/): Recover from broken edits, fix-the-fix loops, cascading test failures, and bloated context with Claude Code's /rewind, sessions, and verification gates.
- [Claude Code IDE integration: VS Code, JetBrains, and any editor](https://developertoolkit.ai/en/claude-code/quick-start/ide-integration/): Install the Claude Code VS Code extension or JetBrains plugin, pick a safe permission mode, feed editor context, and verify edits with IDE diagnostics.
- [Install Claude Code on macOS, Linux, and Windows](https://developertoolkit.ai/en/claude-code/quick-start/installation/): Install Claude Code with the native installer, Homebrew, WinGet, apt/dnf/apk, or npm, pick a release channel, and prove the install with claude doctor.
- [Set up MCP servers in Claude Code](https://developertoolkit.ai/en/claude-code/quick-start/mcp-setup/): Connect Claude Code to MCP servers with claude mcp add and .mcp.json, pick the right scope, keep secrets out of git, and prove each server works.
- [PRD to plan to tasks in Claude Code: a reviewable path from requirements to code](https://developertoolkit.ai/en/claude-code/quick-start/prd-workflow/): Turn a PRD into acceptance criteria, a plan-mode plan saved in the repo, and a tracked task list in Claude Code, with a test gate on every task.
- [Initialize a project for Claude Code: CLAUDE.md, rules, and memory](https://developertoolkit.ai/en/claude-code/quick-start/project-initialization/): Set up a repo for Claude Code: run /init, trim CLAUDE.md to what Claude cannot infer, scope rules by path, and prove it all loads with /context and a probe.
- [Version control with Claude Code: commits, conflicts, PRs and worktrees](https://developertoolkit.ai/en/claude-code/quick-start/version-control/): Let Claude Code split commits, resolve conflicts, open PRs and run parallel worktrees, with tests and review proving each change before it merges.
- [Claude Code reference - versions, channels, and upgrades](https://developertoolkit.ai/en/claude-code/reference/): Check your Claude Code version and release channel, find the page for changelogs, upgrades, and previews, and prove an update did not break your setup.
- [Beta features and research previews in Claude Code](https://developertoolkit.ai/en/claude-code/reference/beta-features/): Which Claude Code features are research previews, betas or experimental, how to turn each on or off, trial it safely, and report what breaks.
- [Claude Code version history](https://developertoolkit.ai/en/claude-code/reference/changelog/): Claude Code releases from 1.0.0 to 2.1.296 with dates, the changes that break scripts and settings, and a safe upgrade routine for CI and teams.
- [Claude Code upgrade procedures](https://developertoolkit.ai/en/claude-code/reference/upgrade-procedures/): Upgrade Claude Code safely - pick a release channel, back up config, update per install type, verify with a scripted smoke test, and roll back.
- [Review and ship with Claude Code](https://developertoolkit.ai/en/claude-code/ship/): Take a Claude Code change from diff to production: /code-review, a headless pre-push gate, PR review, owner sign-off and a rollback you have rehearsed.
- [Running Claude Code in CI/CD with GitHub Actions and headless mode](https://developertoolkit.ai/en/claude-code/ship/ci-cd-integration/): Run Claude Code in GitHub Actions and headless CI jobs for @claude requests, PR review, issue-to-PR and CI auto-fix, with gates, security and cost caps.
- [Pipeline configuration with Claude Code](https://developertoolkit.ai/en/claude-code/ship/ci-cd/): Generate, speed up and harden GitHub Actions and GitLab CI pipelines with Claude Code, and prove each change with actionlint, zizmor and a timed run.
- [Docker and Kubernetes setup with Claude Code](https://developertoolkit.ai/en/claude-code/ship/containerization/): Generate Dockerfiles, Compose stacks, Kubernetes manifests and Helm charts with Claude Code, then prove them with hadolint, Trivy, kubeconform and kind.
- [Deployment automation with Claude Code](https://developertoolkit.ai/en/claude-code/ship/deployment/): Let Claude Code write pre-deploy gates, migration reviews, deploy and rollback scripts, and release notes, and prove each one on staging instead of reading it.
- [Automated code reviews with Claude Code](https://developertoolkit.ai/en/claude-code/ship/review-automation/): Make Claude Code review every diff before a human does: /code-review, managed Code Review with a merge gate, REVIEW.md and the layers Anthropic's team uses.
- [Claude Code for teams and enterprises](https://developertoolkit.ai/en/claude-code/team/): Roll Claude Code out to a team in the right order: network, model route, shared repo config, managed settings, dev containers and Claude Tag, with proof it holds.
- [Claude Tag: a shared Claude Code identity in Slack](https://developertoolkit.ai/en/claude-code/team/claude-tag/): Roll out Claude Tag so anyone can tag @Claude in Slack for Claude Code work: access bundles, repository grants, audit trails, and PR checks.
- [Dev container setup for Claude Code](https://developertoolkit.ai/en/claude-code/team/devcontainer-setup/): Give your team one reproducible dev container with Claude Code: the official feature, persistent sign-in, pinned policy, an egress firewall and a CI smoke test.
- [Enterprise Integration and Security](https://developertoolkit.ai/en/claude-code/team/enterprise-integration/): Roll out Claude Code to a whole organization with managed settings: delivery, a baseline policy, sandboxing, telemetry, and how to prove the policy is in force.
- [Configure an LLM gateway for Claude Code](https://developertoolkit.ai/en/claude-code/team/llm-gateway/): Route Claude Code through Amazon Bedrock, Google Cloud, Microsoft Foundry, Claude Platform on AWS or an LLM gateway, and prove every session takes that route.
- [Proxy and VPN Configuration](https://developertoolkit.ai/en/claude-code/team/proxy-configuration/): Run Claude Code behind a corporate proxy, TLS inspection, mTLS, or a VPN: the variables, the host allowlist, rollout, and how to verify it.
- [Team collaboration with shared Claude Code config](https://developertoolkit.ai/en/claude-code/team/team-collaboration/): Commit CLAUDE.md, .claude/settings.json, .mcp.json and team skills so every clone gets the same Claude Code setup, and prove it with a CI check.
- [Test and debug with Claude Code](https://developertoolkit.ai/en/claude-code/test/): Prove a Claude Code change works and find why it fails: locked tests, hook feedback, read-only diagnosis and evidence you check without reading the diff.
- [Debugging with Claude Code in the terminal](https://developertoolkit.ai/en/claude-code/test/debugging/): Pipe errors into Claude Code, investigate read-only, prove the root cause with a failing test, bisect regressions, and triage CI failures headlessly.
- [Test generation and TDD with Claude Code](https://developertoolkit.ai/en/claude-code/test/testing/): Generate tests that match your patterns, run red-green-refactor with the test file locked, and prove the suite catches bugs with hooks, mutation checks and CI.

## Codex

- [Codex](https://developertoolkit.ai/en/codex/): OpenAI Codex for developers and tech leads: ship a first verified change, pick a sandbox and approval policy, prove the output, find the right guide.
- [Codex automation: pick the surface, then prove the result](https://developertoolkit.ai/en/codex/automate/): Run Codex unattended with codex exec, scheduled automations, cloud tasks, worktrees, the SDK, Slack and Linear, and verify each run without reading diffs.
- [Advanced Codex setups: providers, sandboxes and audit trails](https://developertoolkit.ai/en/codex/automate/advanced-techniques/): Route Codex through gateways or local models, tune effort per job, test sandbox limits, and prove what unattended runs did with JSONL and OpenTelemetry.
- [Scheduled Codex automations you can trust unattended](https://developertoolkit.ai/en/codex/automate/automations/): Run recurring Codex tasks in the desktop app or on a CI schedule: tested prompts, tight sandboxes, output you can verify, and fixes for unattended runs.
- [Codex cloud environments: setup, caching, network and best-of-N](https://developertoolkit.ai/en/codex/automate/cloud-environments/): Configure Codex cloud environments: setup and maintenance scripts, secrets, container caching, agent internet access, best-of-N and CLI task gates.
- [Build with the Codex SDK: threads, structured output and verification](https://developertoolkit.ai/en/codex/automate/codex-sdk/): Drive Codex from TypeScript with @openai/codex-sdk: threads, sandbox options, structured output, streaming, resume, and a gate that checks every result.
- [Codex multi-agent workflows: parallel lanes, subagents and cloud fan-out](https://developertoolkit.ai/en/codex/automate/multi-agent-workflows/): Run several Codex agents in parallel: split a feature set into lanes, launch worktree sessions or exec fan-out, then gate and merge each lane safely.
- [Run Codex non-interactively with codex exec](https://developertoolkit.ai/en/codex/automate/non-interactive/): Run Codex from scripts and CI with codex exec: sandbox choice, schema-checked JSON output, JSONL events, resume, API-key auth, and gates that verify the result.
- [Codex in Slack and Linear: delegate issues to cloud tasks](https://developertoolkit.ai/en/codex/automate/slack-linear-integration/): Turn @ChatGPT mentions in Slack and delegated Linear issues into Codex cloud tasks, and verify the pull requests they produce without reading every line.
- [Isolated Codex tasks with Git worktrees](https://developertoolkit.ai/en/codex/automate/worktrees/): Run each Codex task in its own Git worktree with --worktree, /worktree or git worktree add, bootstrap it, prove it with gates, and clean up without losing work.
- [Build with Codex: context, isolation and gates](https://developertoolkit.ai/en/codex/build/): Build features with Codex: load the right context, plan read-only, implement in a worktree, and let tests and codex review decide when the work is done.
- [Optimize AGENTS.md and skills for Codex](https://developertoolkit.ai/en/codex/build/agents-md-optimization/): Keep Codex's AGENTS.md chain inside its 32 KiB budget, move procedures into skills, and prove what loaded with codex debug prompt-input.
- [Build APIs with Codex: contract first, verified by machine](https://developertoolkit.ai/en/codex/build/api-development/): Build REST APIs with Codex: an OpenAPI contract you review, one worktree task per endpoint slice, and lint, test, fuzz and review gates that check the code.
- [Codex desktop app: parallel threads, worktrees and review](https://developertoolkit.ai/en/codex/build/app-mastery/): Run parallel Codex desktop app threads in local, worktree or cloud mode, prove each result with gates and codex review, and bring the work home through Git.
- [Codex batch operations: one change across many packages](https://developertoolkit.ai/en/codex/build/batch-operations/): Apply one change across dozens of packages or repos with Codex: codemod first, pilot one partition, fan out codex exec in worktrees, gate every partition.
- [Codex CLI commands, slash commands and shortcuts](https://developertoolkit.ai/en/codex/build/cli-commands/): Use the Codex CLI well: resume, fork and name sessions, the slash commands worth knowing, TUI shortcuts, image input and review gates, checked on CLI 0.157.1.
- [Legacy code modernization at scale with Codex](https://developertoolkit.ai/en/codex/build/codebase-modernization/): Modernize a legacy codebase with Codex: pin behavior with tests, migrate in parallel worktrees, send hard modules to cloud best-of-N, prove each wave.
- [Context Management Across Codex Surfaces](https://developertoolkit.ai/en/codex/build/context-patterns/): Keep long Codex sessions on track: measure context with /status, control compaction, chain short threads with a handoff file, and move work across surfaces.
- [Database work with Codex: schemas, migrations, and queries you can prove](https://developertoolkit.ai/en/codex/build/database-work/): Design schemas, generate safe Drizzle migrations, and tune PostgreSQL queries with Codex, then prove each change on a seeded database.
- [Generate and maintain documentation with Codex](https://developertoolkit.ai/en/codex/build/documentation/): Generate API references, architecture docs and changelogs with Codex in a worktree, then catch doc drift with codex exec, a JSON schema and CI gates.
- [Codex efficiency hacks: configure once, save time every session](https://developertoolkit.ai/en/codex/build/efficiency-hacks/): Set up Codex once for daily speed: shell aliases, config.toml notifications and status line, effort profiles, and a verification gate that stays fast.
- [Prompt Codex with task briefs, plan mode and AGENTS.md](https://developertoolkit.ai/en/codex/build/prompt-engineering/): Write Codex task briefs that end in executable checks, keep durable rules in AGENTS.md, plan before editing, and verify results without reading every line.
- [Large-scale refactoring with Codex worktrees](https://developertoolkit.ai/en/codex/build/refactoring/): Refactor hundreds of files with Codex: a written plan, an expand step, one worktree per batch, a ratchet on the old API, and gates that prove behavior held.
- [Operate Codex in production](https://developertoolkit.ai/en/codex/operate/): Run Codex day to day: read usage with /status and /usage, export OpenTelemetry, check installs with codex doctor, and audit what Codex ships.
- [Codex Security and the agents command center](https://developertoolkit.ai/en/codex/operate/codex-security/): Route Codex Security and @codex security review findings through one tested review flow, with least-privilege Codex sessions and the agents command center.
- [Codex credits, usage limits and cost optimization](https://developertoolkit.ai/en/codex/operate/cost-management/): Make Codex allowances and credits last: read /status and /usage, set model and effort per job, trim context, and bound unattended runs.
- [Performance optimization with Codex](https://developertoolkit.ai/en/codex/operate/performance/): Find a slow endpoint's bottleneck with Codex, commit a benchmark first, try competing fixes as best-of-N cloud tasks, and accept only what the numbers prove.
- [Security audits with Codex](https://developertoolkit.ai/en/codex/operate/security-audit/): Audit a codebase with Codex CLI: scanners first, parallel read-only audits per domain, exploit tests before fixes in worktrees, and AGENTS.md rules that stick.
- [Plan with Codex: a decision-complete plan before any edit](https://developertoolkit.ai/en/codex/plan/): Codex planning guides for developers and tech leads: map a codebase, design a system, and start a project from a plan you can verify.
- [System design with Codex](https://developertoolkit.ai/en/codex/plan/architecture/): Design a service split with Codex: map the code read-only, test risky assumptions as cloud spikes, compare designs in worktrees and enforce the decision in CI.
- [Understanding an unfamiliar codebase with Codex](https://developertoolkit.ai/en/codex/plan/codebase-analysis/): Map an unfamiliar repository with Codex in a read-only sandbox, subagents and cloud tasks, then prove the map with checked citations and a passing test.
- [Start a new project with Codex](https://developertoolkit.ai/en/codex/plan/new-project/): Bootstrap a new service with Codex: spec first, scaffold only the tooling, prove the gates can fail, write AGENTS.md, then ship a feature from a worktree.
- [Codex quick start: from install to a verified first task](https://developertoolkit.ai/en/codex/quick-start/): The Codex quick start for developers: pick a surface, install, sign in, configure, and ship a first task you verify with tests and a review pass.
- [Set up AGENTS.md for Codex](https://developertoolkit.ai/en/codex/quick-start/agents-md/): Write a global and a project AGENTS.md for Codex, check exactly what loaded with codex debug prompt-input, and prove the rules change what Codex does.
- [Authentication](https://developertoolkit.ai/en/codex/quick-start/authentication/): Choose ChatGPT sign-in or an API key for Codex, store credentials safely, sign in over SSH and in CI, and prove it worked with login status and doctor.
- [Configure Codex with config.toml: model, permissions, and profiles](https://developertoolkit.ai/en/codex/quick-start/configuration/): Set up Codex config.toml deliberately: layer precedence, model and effort, permission profiles, secret filtering, profiles, and how to prove each setting applies.
- [Recover from Codex errors and wrong turns](https://developertoolkit.ai/en/codex/quick-start/error-recovery/): Diagnose a Codex failure, apply the right fix, and roll back with Git: sandbox blocks, failed commands, wrong-direction edits, long threads, MCP and login.
- [Run your first Codex task](https://developertoolkit.ai/en/codex/quick-start/first-task/): Run a first real Codex task end to end: pick a task a test can prove, prompt with acceptance criteria, run it in the CLI or cloud, and verify the diff.
- [Connect Codex to GitHub](https://developertoolkit.ai/en/codex/quick-start/github-integration/): Connect Codex to GitHub: set up a cloud environment, turn on @codex review, write AGENTS.md review rules, start tasks from issues and gate merges on CI.
- [Install Codex: CLI, desktop app, and IDE extension](https://developertoolkit.ai/en/codex/quick-start/installation/): Install the Codex CLI, desktop app, and IDE extension on macOS, Linux, or Windows, then prove the setup works with codex doctor and a read-only smoke test.
- [Set up MCP servers in Codex](https://developertoolkit.ai/en/codex/quick-start/mcp-setup/): Connect Codex to MCP servers with codex mcp add and config.toml, scope their tools and secrets, and prove each server works before trusting its output.
- [Review Codex's changes before you commit](https://developertoolkit.ai/en/codex/quick-start/review-workflow/): Check Codex's work without reading every line: run your gates, run /review or codex review, triage P0–P3 findings, keep good hunks with Git, then commit.
- [Staying current with Codex](https://developertoolkit.ai/en/codex/reference/): Check which Codex version you run, update the CLI, IDE extension and desktop app, and set a team pin policy so a Codex release never breaks CI by surprise.
- [Codex version history](https://developertoolkit.ai/en/codex/reference/changelog/): Codex CLI releases 0.95.0 to 0.162.1 with dates, highlights and the changes that break scripts, plus a safe upgrade routine for CI and team config.
- [Review and ship with Codex](https://developertoolkit.ai/en/codex/ship/): Take a Codex-written change from diff to production: layered review, CI gates with codex-action, merge evidence and deployment you can roll back.
- [Run Codex in CI/CD with the GitHub Action](https://developertoolkit.ai/en/codex/ship/ci-cd/): Run openai/codex-action in GitHub Actions for PR review, a structured security gate, draft release notes and CI auto-fix, hardened for secrets.
- [Code review with Codex: one standard across CLI, desktop app and GitHub](https://developertoolkit.ai/en/codex/ship/code-review/): Run Codex review as a layered gate: pre-push codex exec review, @codex review on pull requests, shared AGENTS.md rules and a seeded-bug check on the reviewer.
- [Automate deployments with Codex: containers, deploy scripts and rollback](https://developertoolkit.ai/en/codex/ship/deployment/): Use Codex to write and test your Dockerfile, deploy and rollback scripts and migrations, while CI evidence and a protected environment gate production.
- [Pull request automation with Codex](https://developertoolkit.ai/en/codex/ship/pr-automation/): Take a Codex change from worktree to merge: a draft PR with evidence, codex review and @codex review, bounded CI fixes, and merge rules that decide.
- [Review Codex work without becoming the bottleneck](https://developertoolkit.ai/en/codex/ship/review-strategies/): Scale review of Codex output by risk class: set permissions before the run, demand an evidence report, route each class to the right review and sign-off.
- [Codex for teams and enterprises](https://developertoolkit.ai/en/codex/team/): Roll Codex out to a team in order: sign-in, committed repo config, a requirements.toml floor nobody can override, and checks that prove it holds.
- [Codex enterprise governance: requirements.toml, access and audit](https://developertoolkit.ai/en/codex/team/enterprise-governance/): Govern Codex across teams: workspace access, an enforced requirements.toml, rollout by MDM or file, audit evidence, and a CI check that proves the policy holds.
- [Team collaboration and shared configuration in Codex](https://developertoolkit.ai/en/codex/team/team-workflows/): Share one Codex setup across a team: committed AGENTS.md, .codex/config.toml, tested rules and skills, a one-session onboarding, and a CI gate.
- [Test and debug with Codex](https://developertoolkit.ai/en/codex/test/): Prove a Codex change works and find why it fails: test commands in AGENTS.md, read-only diagnosis, failing tests first and evidence instead of diff reading.
- [Debugging and bug hunting with Codex](https://developertoolkit.ai/en/codex/test/bug-hunting/): Debug with Codex reproduction-first: choose the CLI, a worktree, cloud or an @codex mention per bug, and prove each fix with a test that fails before it.
- [Test generation and execution with Codex](https://developertoolkit.ai/en/codex/test/testing/): Close coverage gaps with Codex: one worktree lane per module, a tests-only gate, coverage deltas, mutation checks and codex review before any merge.

## Workflows & method: Method

- [The method: specify, verify, then delegate](https://developertoolkit.ai/en/method/): How agent work gets done: commit an artifact chain, verify before you raise autonomy, and read evidence at the gates instead of every diff.
- [The AI-native software development lifecycle](https://developertoolkit.ai/en/method/lifecycle/): Run plan, design, build, test, deploy, and maintain as one loop: each stage commits an artifact, gates check evidence, and a named human signs off.
- [The artifact chain](https://developertoolkit.ai/en/method/lifecycle/artifact-chain/): Turn a ticket into intent.md, spec.md, plan.md, a diff with test evidence, and review findings, each committed and accepted before the next stage starts.
- [Build: plan.md, then implement](https://developertoolkit.ai/en/method/lifecycle/build/): Turn an accepted spec.md into a committed plan.md in read-only plan mode, then implement in an isolated worktree behind hooks and a self-check.
- [Deploy: review in both directions, gate production](https://developertoolkit.ai/en/method/lifecycle/deploy/): Give every pull request an agent review, let the authoring agent close its own threads, and keep merge and production behind gates the agent cannot pass.
- [Design: write spec.md](https://developertoolkit.ai/en/method/lifecycle/design/): Turn an accepted intent.md into a committed spec.md in one agent session, with policy skills applied and every conflict flagged before build starts.
- [Maintain: close the loop](https://developertoolkit.ai/en/method/lifecycle/maintain/): Turn a production alert into an evidence-backed intent.md with no one starting a session: deterministic detection, read-only diagnosis, human triage.
- [Metrics for an AI-native SDLC](https://developertoolkit.ai/en/method/lifecycle/metrics/): One leading and one lagging indicator per lifecycle stage, read from git, pull requests, CI and incidents, to show where the agent loop slows or leaks.
- [Plan: capture intent.md](https://developertoolkit.ai/en/method/lifecycle/plan/): Turn an idea, ticket, or incident into an intent.md the product owner accepts before design: agent interview, template, CI shape check, and recovery steps.
- [Test: give the session a feedback loop](https://developertoolkit.ai/en/method/lifecycle/test/): Give every agent session one-command checks, a measurable definition of done, a Stop hook, a fresh-context verifier and evals for its own configuration.
- [Tool map: Claude Code, Cursor, and Codex](https://developertoolkit.ai/en/method/lifecycle/tool-map/): Map each AI-native lifecycle stage to Claude Code, Codex, and Cursor features checked on the installed CLIs, keeping the artifacts and gates in Git.
- [Principles for working with coding agents](https://developertoolkit.ai/en/method/principles/): The tool-independent rules under every agent workflow: read-only until planned, tests first, errors as specs, small batches, and human judgment at the gates.
- [When to use agent mode vs ask mode](https://developertoolkit.ai/en/method/principles/agent-vs-ask-mode/): Read-only plan mode, write mode or unattended runs in Claude Code, Codex and Cursor: which to pick per task, the exact switches, and how to check the result.
- [Continuous Delivery with AI Assistance](https://developertoolkit.ai/en/method/principles/continuous-delivery/): Keep agent changes small enough to prove: one task per commit, a PR size budget in CI, automated gates before merge, and flags between deploy and release.
- [Error-Driven Development](https://developertoolkit.ai/en/method/principles/error-driven-development/): Turn compiler errors, failing tests, and stack traces into agent prompts, run a bounded fix-and-rerun loop, and prove it converged without reading the diff.
- [Human in the loop: judgment at the gates, not in every diff](https://developertoolkit.ai/en/method/principles/human-in-the-loop/): Where human judgment belongs when agents write the code: four gates (intent, spec, evidence, risk class), with code reading kept for the escalation classes.
- [Effective prompting techniques for coding agents](https://developertoolkit.ai/en/method/principles/prompting-techniques/): Prompt patterns that make Claude Code, Codex and Cursor produce checkable work: clarify first, constrain, show an example, plan, then prove the result.
- [Software Factories: How to Build One and Keep It From Rotting](https://developertoolkit.ai/en/method/principles/software-factories/): What a software factory is, why agent-built codebases erode, and how to grant autonomy loop by loop with an oracle, a WIP limit and rot metrics.
- [Test-driven development with AI agents](https://developertoolkit.ai/en/method/principles/test-driven-development/): Red test first, then let the agent implement: the four-phase TDD loop, test-first bug fixing, locked test files, and proof the green run is real.

## Workflows & method: Workflows, all tools

- [Shared workflows: the cross-tool hub](https://developertoolkit.ai/en/workflows/): The cross-tool workflows for Claude Code, Codex and Cursor, grouped by lifecycle stage: context, harness, plan, build, test, ship, operate and automate.
- [Automate](https://developertoolkit.ai/en/workflows/automate/): Run Claude Code, Codex and Cursor unattended: goals, schedules, cloud agents, issue-to-PR pipelines and SDKs, with the gates that prove the output.
- [Driving agents from code: Claude Agent SDK, Codex SDK and Cursor SDK](https://developertoolkit.ai/en/workflows/automate/agent-sdks/): When to script a coding agent instead of triggering one, and how the Claude Agent SDK, Codex SDK and Cursor SDK differ, with one CI-triage job written in each.
- [Background and cloud agents compared](https://developertoolkit.ai/en/workflows/automate/background-agents/): Claude Code cloud sessions and routines, Codex cloud, Cursor Cloud Agents, Copilot cloud agent and Jules compared on environment, triggers, limits and cost.
- [The /goal Command: Goal-Directed Autonomous Runs](https://developertoolkit.ai/en/workflows/automate/goal-command/): How /goal keeps Claude Code, Codex and Cursor working until a verifiable finish line holds, who judges done in each tool, and how to prove the result.
- [From intent to production: a worked end-to-end pipeline](https://developertoolkit.ai/en/workflows/automate/intent-to-production/): Extend an issue-to-PR pipeline past the merge: auto-merge by risk class, progressive delivery, SLO-triggered rollback and every incident turned into an eval.
- [From issue to pull request with no hands on the keyboard](https://developertoolkit.ai/en/workflows/automate/issue-to-pr-pipeline/): A labelled issue becomes a review-ready PR in Claude Code, Codex or Cursor: isolated agent run, independent gates, a capped fix loop and an evidence bundle.
- [The /loop Command: Recurring and Self-Paced Prompts](https://developertoolkit.ai/en/workflows/automate/loop-command/): Run a prompt on a schedule or a self-chosen interval with /loop in Claude Code and Cursor, make every run prove its result, and know what Codex uses instead.
- [Multi-agent orchestration patterns: planner, workers, judge](https://developertoolkit.ai/en/workflows/automate/orchestration-patterns/): Fan-out/fan-in, pipelines, best-of-N with a judge and writer/reviewer: when each multi-agent pattern pays off, what it costs, and how to run it in each tool.
- [Build with agents: the workflow for your codebase](https://developertoolkit.ai/en/workflows/build/): Build with Claude Code, Codex, or Cursor: pick the guide for your codebase shape, then plan, slice, and gate every change so tests prove it.
- [API development with AI: contract first, verified by machine](https://developertoolkit.ai/en/workflows/build/api-development/): Build REST, GraphQL and gRPC APIs with Claude Code, Codex or Cursor: a contract you review, agent-built slices, and gates that prove the code matches it.
- [Database Design and Queries](https://developertoolkit.ai/en/workflows/build/database-development/): Connect Claude Code, Codex, or Cursor to your database through a read-only MCP server, then design schemas, tune queries, and prove migrations safe.
- [Million+ LOC strategies for coding agents](https://developertoolkit.ai/en/workflows/build/large-codebases/): Work in million-line codebases with Claude Code, Codex and Cursor using layered instruction files, code-intelligence MCP, blast-radius reports and gates.
- [Legacy modernization with agents: a program, not a prompt](https://developertoolkit.ai/en/workflows/build/legacy-modernization/): Run a legacy migration with coding agents as a gated program: characterization tests, seams and slices, parallel waves, shadow comparison and cut-over evidence.
- [Distributed Systems Development with AI](https://developertoolkit.ai/en/workflows/build/microservices/): Build microservices with Claude Code, Codex and Cursor contract-first, so sagas, trace context and schema changes are proved by tests, not by reading diffs.
- [Monorepo Workflows with AI Assistants](https://developertoolkit.ai/en/workflows/build/monorepo-management/): Give Claude Code, Codex and Cursor your monorepo's project graph, run impact analysis before edits, refactor bottom-up, and prove it with affected-only gates.
- [Context management for coding agents](https://developertoolkit.ai/en/workflows/context/): How to keep Claude Code, Codex, and Cursor working from the right context: which page fixes which problem, the reset commands, and how to check.
- [Code search and indexing for AI agents: text, semantic and symbol search](https://developertoolkit.ai/en/workflows/context/codebase-indexing/): How Claude Code, Codex and Cursor find code, which search fits which question, how to cut noise, and how to check the agent's findings without reading every file.
- [Context windows and token limits for coding agents](https://developertoolkit.ai/en/workflows/context/context-windows/): How a coding agent's context window fills, how to measure it in Claude Code, Codex and Cursor, and when to compact, clear or delegate before quality drops.
- [Context cost optimization for coding agents](https://developertoolkit.ai/en/workflows/context/cost-per-context/): Cut coding-agent spend in Claude Code, Codex and Cursor: measure where tokens go, trim context, route models by task, and prove quality held.
- [Using Documentation as Effective AI Context](https://developertoolkit.ai/en/workflows/context/documentation-as-context/): Write CLAUDE.md, AGENTS.md and Cursor rules that agents follow: what goes in, how each tool loads them, and how to prove the file still matches the repo.
- [Project structure optimized for AI coding agents](https://developertoolkit.ai/en/workflows/context/file-organization/): Lay out files, names, tests and scoped instructions so Claude Code, Codex and Cursor load only what a task needs, then prove the layout holds in CI.
- [Long-Term Context Retention Patterns](https://developertoolkit.ai/en/workflows/context/memory-patterns/): Decide what Claude Code, Codex and Cursor should remember across sessions, store each fact in the right layer, and prove the memory loaded and still holds.
- [Prune CLAUDE.md and AGENTS.md: the ablation protocol](https://developertoolkit.ai/en/workflows/context/pruning-context-files/): Cut CLAUDE.md, AGENTS.md and Cursor rules instead of adding a line per mistake: what each tool loads, where each rule belongs, and six prompts that prune.
- [The harness: everything the agent runs inside](https://developertoolkit.ai/en/workflows/harness/): The seven layers around a coding agent: context, tools, permissions, hooks, skills, plugins and environments. What each prevents, and how to test the harness.
- [Making a codebase agent-ready](https://developertoolkit.ai/en/workflows/harness/agent-ready-codebase/): Six repository properties that let checks replace reading agent diffs, with a 0–3 score for each, an audit prompt, and the order to fix them in.
- [Ephemeral environments: a full stack per agent task](https://developertoolkit.ai/en/workflows/harness/ephemeral-environments/): Give every agent task its own seeded stack: a port block, a per-task database, service stubs and teardown, locally or in Claude Code, Codex and Cursor clouds.
- [Permissions, sandboxes and approval modes across Claude Code, Codex and Cursor](https://developertoolkit.ai/en/workflows/harness/permissions-and-sandboxing/): A cross-tool matrix of approval modes, OS sandboxes and network egress in Claude Code, Codex and Cursor, with the posture to use per risk class and run type.
- [DevOps with AI](https://developertoolkit.ai/en/workflows/operate/): Run production with Claude Code, Codex, and Cursor: read-only MCP access to live signals, agent-drafted fixes, and gates that prove each change.
- [Observing the agents: traces, tool calls, cost and audit logs](https://developertoolkit.ai/en/workflows/operate/agent-observability/): Export agent telemetry with OpenTelemetry, join runs to pull requests and incidents, build a run-success and cost-per-change dashboard, and set audit retention.
- [Cloud cost management and FinOps with coding agents](https://developertoolkit.ai/en/workflows/operate/cloud-cost-optimization/): Explain a cloud bill, rank waste and turn right-sizing into reviewed Terraform with Claude Code, Codex and Cursor on read-only billing MCP servers.
- [Keeping an agent-written codebase healthy](https://developertoolkit.ai/en/workflows/operate/codebase-health/): Track rework, reverts, complexity, duplication and hotspots weekly, lower a loop's autonomy on set thresholds, and run scheduled refactor loops.
- [Regulatory Compliance Automation](https://developertoolkit.ai/en/workflows/operate/compliance-automation/): Use Claude Code, Codex or Cursor to map SOC 2, HIPAA and GDPR controls to code, wire CI gates and collect audit evidence you can check without rereading it.
- [AI-Powered Disaster Recovery](https://developertoolkit.ai/en/workflows/operate/disaster-recovery/): Recover from an agent's bad change and from lost infrastructure with revertable commits, PITR runbooks, drift checks and chaos drills that prove RTO and RPO.
- [A failure taxonomy for agent-written changes](https://developertoolkit.ai/en/workflows/operate/failure-taxonomy/): Seven failure classes for agent-written changes, each mapped to the earliest control that catches it, plus a tag schema, a classifier and a ranking report.
- [AI-powered incident response](https://developertoolkit.ai/en/workflows/operate/incident-response/): Run incidents with Claude Code, Codex or Cursor on read-only MCP servers, from sourced timeline to gated mitigation, measured recovery and a post-mortem.
- [Monitoring and observability](https://developertoolkit.ai/en/workflows/operate/monitoring-observability/): Have Claude Code, Codex or Cursor instrument a service with OpenTelemetry, generate alerts and dashboards, and prove them with promtool tests and MCP queries.
- [Production Performance Optimization](https://developertoolkit.ai/en/workflows/operate/performance-tuning/): Diagnose p99 regressions, pool exhaustion and flapping autoscalers with an agent on read-only Kubernetes, Postgres and metrics MCP servers.
- [Security Operations Automation](https://developertoolkit.ai/en/workflows/operate/security-operations/): Run Semgrep, npm audit, Trivy and Gitleaks as CI gates, let Claude Code, Codex or Cursor triage the findings to a schema, and ship fixes as reviewed PRs.
- [Plan and specify: the contract before the code](https://developertoolkit.ai/en/workflows/plan/): Plan with Claude Code, Codex, and Cursor: intent, spec, executable acceptance criteria, ADRs, and a visual contract a human approves before code exists.
- [Executable acceptance criteria: from story to failing test](https://developertoolkit.ai/en/workflows/plan/acceptance-criteria/): Turn each acceptance criterion into a Given/When/Then scenario and a failing test before the agent codes, lock it, and approve the contract instead of the diff.
- [Agile Workflows: Scrum and Kanban Integration](https://developertoolkit.ai/en/workflows/plan/agile-workflows/): Run Scrum and Kanban with coding agents: refine stories, plan to review capacity, cap WIP on evidence review, and draft sprint reviews from merged PRs.
- [Architecture decisions agents can follow](https://developertoolkit.ai/en/workflows/plan/architecture-decisions/): Write short ADRs whose constraints name a CI check, load them into Claude Code, Codex and Cursor, and stop agents from quietly eroding the architecture.
- [Behavior-driven development with AI agents](https://developertoolkit.ai/en/workflows/plan/behavior-driven-dev/): Use approved Gherkin scenarios as the contract an AI agent codes against: example mapping, locked feature files, Cucumber.js glue, and CI gates.
- [Domain-driven design with AI coding agents](https://developertoolkit.ai/en/workflows/plan/domain-driven-design/): Give Claude Code, Codex and Cursor your ubiquitous language, pin aggregate invariants as tests first, and enforce bounded contexts with a CI dependency rule.
- [Four-artifact design-to-code pipeline](https://developertoolkit.ai/en/workflows/plan/four-stage-pipeline/): Take a UI from intent to verified code through four gated artifacts: visual direction, prototype, design contract, and implementation with proof.
- [Evidence-based rating and iteration](https://developertoolkit.ai/en/workflows/plan/rating-loop/): Rate a design or spec handoff with a read-only reviewer, a JSON rubric, and a scripted gate, then iterate until a threshold or a stop condition.
- [Spec-driven development: the spec as the source of truth](https://developertoolkit.ai/en/workflows/plan/spec-driven-development/): Keep spec.md authoritative with agents: a spec delta in every PR, CI checks that catch drift, and plain markdown vs Spec Kit, OpenSpec, Kiro and BMAD.
- [Review and ship](https://developertoolkit.ai/en/workflows/ship/): Ship agent-written changes on evidence: a PR bundle CI enforces, review-agent triage, pipeline gates, progressive delivery and rehearsed rollback.
- [Reviewing an agent's pull request without reading every line](https://developertoolkit.ai/en/workflows/ship/agent-pr-review/): A six-step triage for agent pull requests: spec delta, evidence, risk flags, oracle changes, sampled hotspots, then approve, return or escalate.
- [Pipeline automation with AI](https://developertoolkit.ai/en/workflows/ship/ci-cd-pipelines/): Have Claude Code, Codex or Cursor write change-aware CI and triage flaky tests, with gates that prove each agent edit still protects main.
- [Docker and Kubernetes Containerization](https://developertoolkit.ai/en/workflows/ship/containerization/): Have Claude Code, Codex, or Cursor write hardened Dockerfiles and Kubernetes manifests, debug OOMKilled pods, and prove the result with scanners, not reading.
- [The evidence bundle: what an agent's pull request must prove](https://developertoolkit.ai/en/workflows/ship/evidence-bundle/): The pull request contract for agent changes: spec delta, acceptance results, checks, runtime evidence, risk class, provenance, and a CI check that enforces it.
- [Infrastructure as code with AI agents](https://developertoolkit.ai/en/workflows/ship/infrastructure-code/): Let Claude Code, Codex or Cursor write Terraform, CloudFormation, CDK and Pulumi changes while CI proves them with gates, plans and drift checks.
- [Progressive delivery for agent-written changes](https://developertoolkit.ai/en/workflows/ship/progressive-delivery/): Feature flags, canaries and SLO-triggered automatic rollback as the net under agent changes you did not read, with a blast-radius budget per risk class.
- [Testing and verification for agent-written code](https://developertoolkit.ai/en/workflows/test/): Where to start verifying agent-written code: the test pages in the order you need them, from oracle strength to the evidence a reviewer reads.
- [Accessibility testing with AI agents: WCAG 2.2 AA gates in CI](https://developertoolkit.ai/en/workflows/test/accessibility-testing/): Gate agent-written UI on WCAG 2.2 AA: an axe-core baseline in Playwright, keyboard tests, a browser MCP for audits, and a human screen-reader pass.
- [API Test Automation](https://developertoolkit.ai/en/workflows/test/api-testing/): Have agents write REST and GraphQL tests from the contract, an authorization matrix and Pact contracts, then prove the suite catches bugs without reading it.
- [Characterization tests: pin legacy behavior before agents touch it](https://developertoolkit.ai/en/workflows/test/characterization-tests/): Pin what legacy code does today with snapshot, approval, and golden-master tests at a seam, prove they can fail, and lock them before an agent refactors.
- [Code quality gates for agent-written code](https://developertoolkit.ai/en/workflows/test/code-quality/): Run format, lint, type and static-analysis checks inside the agent loop and as required CI jobs, with AI review as advice, not the gate.
- [Hallucinated packages and slopsquatting: dependency checks for agent changes](https://developertoolkit.ai/en/workflows/test/dependency-verification/): Stop agents adding invented, typosquatted, too-new or wrongly licensed packages: a lockfile-diff CI gate, cooldowns, a registry proxy and an approval hook.
- [End-to-End Test Automation](https://developertoolkit.ai/en/workflows/test/e2e-testing/): Have agents write and maintain a Playwright E2E suite from acceptance criteria, and prove it catches regressions without reading every spec.
- [Fault injection testing: prove timeouts, retries, and circuit breakers fire](https://developertoolkit.ai/en/workflows/test/error-injection-testing/): Write a fault matrix, let Claude Code, Codex, or Cursor build Toxiproxy and Chaos Mesh tests, and prove timeouts, retries, and breakers really fire.
- [Architecture fitness functions: maintainability without reading the code](https://developertoolkit.ai/en/workflows/test/fitness-functions/): Gate layering, cycles, complexity, duplication and API surface in CI with ratchets, so agent-written code stays maintainable without line-by-line review.
- [Integration Test Patterns](https://developertoolkit.ai/en/workflows/test/integration-testing/): Have agents write integration tests against a real database, queue and stubbed third-party APIs, then prove each test can fail without reading the suite.
- [Mobile app testing with AI agents](https://developertoolkit.ai/en/workflows/test/mobile-testing/): Have agents write and run Detox, Maestro and Flutter tests on real simulators, choose a device matrix, and prove the tests catch bugs before you trust them.
- [Model-graded checks: rubric judges where tests cannot reach](https://developertoolkit.ai/en/workflows/test/model-graded-checks/): Grade UX copy, docs, screenshots, and review findings with a rubric judge: calibration set, agreement metrics, spot-checks, and no self-grading.
- [How strong is your oracle? Trusting tests you did not read](https://developertoolkit.ai/en/workflows/test/oracle-strength/): Measure whether a test suite catches bugs: mutation score, behaviour coverage, test provenance and flake rate, and the bar a loop must clear to run unattended.
- [Load, Stress, and Benchmark Testing](https://developertoolkit.ai/en/workflows/test/performance-testing/): Have an agent write k6 load and stress tests from your latency targets, rank bottlenecks from the evidence, and gate p95 regressions in CI.
- [Property-based testing for agent-written code](https://developertoolkit.ai/en/workflows/test/property-based-testing/): Turn spec.md requirements into invariants that fast-check, Hypothesis and proptest check on generated inputs, and pin every shrunk failure as a regression test.
- [Protecting the oracle: checks the agent cannot edit](https://developertoolkit.ai/en/workflows/test/protect-the-oracle/): Lock tests with deny rules, sandbox profiles and CODEOWNERS, run the decisive check from CI outside the diff, keep holdouts out of the repo, and flag weakening.
- [Security testing for agent-written code](https://developertoolkit.ai/en/workflows/test/security-testing/): Prove agent-written code is secure with tests, not opinions: authorization matrices, abuse-case tests, and an exploit test for every AI review finding.
- [Catching plausible-but-wrong code before merge](https://developertoolkit.ai/en/workflows/test/slop-detection/): A catalog of five slop patterns in agent-written code, each with a tested lint or CI detector and a review-agent prompt for what the detector misses.
- [Test data strategies and fixtures](https://developertoolkit.ai/en/workflows/test/test-data-management/): Have agents build deterministic factories, scenario seeds and PII-free synthetic data, then prove them with contract tests, seed diffs and a PII gate.
- [Unit test strategies and generation with AI agents](https://developertoolkit.ai/en/workflows/test/unit-testing/): Get unit tests from an agent that catch real bugs: an approved behaviour list, mocks only at boundaries, a negative control per test, and mutation-tested files.

## Ecosystem & comparisons: Choose a tool

- [Tool Comparison Overview](https://developertoolkit.ai/en/comparison/): Cursor, Claude Code and Codex run one agent loop on three surfaces. Pick by where you work and what runs unattended, then prove it with a one-task bake-off.
- [The coding-agent landscape beyond the big three](https://developertoolkit.ai/en/comparison/agent-landscape/): Coding agents beyond Claude Code, Codex and Cursor, grouped by where each runs and what it automates, plus the site's bake-off protocol to test one.
- [Cursor vs Claude Code: when to use which](https://developertoolkit.ai/en/comparison/cursor-vs-claude-code/): Cursor or Claude Code? A task-by-task decision table, prompts for each, one verification gate for both, and how to run the two on one repository.
- [Cursor vs Claude Code vs Codex: feature comparison matrix](https://developertoolkit.ai/en/comparison/feature-matrix/): Claude Code, Codex and Cursor compared row by row, version-stamped: surfaces, guardrails, review, headless runs, plus prompts to verify rows on your repo.
- [Gemini CLI, Jules and Antigravity](https://developertoolkit.ai/en/comparison/gemini-cli/): Google's three coding agents: what Gemini CLI, Jules and Antigravity automate, who kept free access after June 2026, and how each fits a big-three harness.
- [GitHub Copilot as a coding agent: cloud agent, app, CLI and billing](https://developertoolkit.ai/en/comparison/github-copilot/): GitHub Copilot's cloud agent, desktop app and CLI, skills, hooks, MCP, AI-credit billing since 1 June 2026, the Claude and Codex agents, and org policy.
- [Kiro: spec files, property-based tests and Kiro Crew](https://developertoolkit.ai/en/comparison/kiro/): Kiro's spec workflow, property-based tests and open-source Kiro Crew, plus its plans checked 2026-10-12, and how to borrow each on Claude Code, Codex or Cursor.
- [Moving to Cursor, Claude Code, or Codex: a migration guide](https://developertoolkit.ai/en/comparison/migration-guide/): Switch a team to Cursor, Claude Code, or Codex: choose the tool, import the config, prove it on your repo, roll out in stages, measure, keep a rollback.
- [OpenCode: the open-source agent for any model](https://developertoolkit.ai/en/comparison/opencode/): OpenCode 1.19.0 on npm 2026-10-12, behaviour checked on 1.18.32: setup, model routing across hosted and open-weight models, and where it matches Claude Code, Codex and Cursor.
- [AI coding tool plan prices and how usage is billed](https://developertoolkit.ai/en/comparison/pricing-analysis/): What each coding-agent plan costs on 2026-10-12, how usage is metered beyond the seat, and a worksheet that prices a team from real invoices.
- [From plain chat to integrated development](https://developertoolkit.ai/en/comparison/vs-chatgpt/): When plain ChatGPT chat is enough and when to move the work to Codex, Claude Code, or Cursor, and how to verify the agent's diff without reading every line.
- [Codex vs Cursor and Claude Code: strengths and trade-offs](https://developertoolkit.ai/en/comparison/vs-codex/): Where OpenAI Codex's multi-surface model beats Cursor and Claude Code, where it costs you, and one verification gate all three must pass.
- [Claude Code, Codex and Cursor vs GitHub Copilot](https://developertoolkit.ai/en/comparison/vs-github-copilot/): GitHub Copilot is a full agent platform in 2026. Compare it with Claude Code, Codex and Cursor on harness, limits, models and billing, then run a fair bake-off.
- [Cursor, Claude Code, and Codex vs Devin Desktop (formerly Windsurf)](https://developertoolkit.ai/en/comparison/vs-windsurf/): Devin Desktop, formerly Windsurf, against Cursor, Claude Code and Codex: what could be verified on 2026-09-26 and 2026-10-12, a decision table and a same-task bake-off.

## Ecosystem & comparisons: Models, MCP, skills and agent tools

- [Skills, MCP servers or plugins: which one, and where each lives](https://developertoolkit.ai/en/ecosystem/): Choose between AGENTS.md, a skill, a slash command, a subagent, a hook, an MCP server and a plugin, then find the ecosystem shelf that covers each one.
- [Agent tools: multiplexers, desktop environments, sandboxes, gateways and more](https://developertoolkit.ai/en/ecosystem/agent-tools/): Third-party tools around Claude Code, Codex and Cursor: six shelves, the built-ins to try first, license traps, and a checklist for adding a tool.
- [Desktop agent environments compared: Orca, Conductor, Superset, Emdash, Warp and more](https://developertoolkit.ai/en/ecosystem/agent-tools/agent-shells/): Compare desktop apps that run Claude Code, Codex and Cursor's CLI in parallel worktrees: Orca, Conductor, Superset, Emdash, Warp. Licences, platforms, traps.
- [Gateways and Local Models: LiteLLM, CC Switch, Claude Code Router, Ollama and LM Studio](https://developertoolkit.ai/en/ecosystem/agent-tools/gateways-local-models/): Route Claude Code and Codex through LiteLLM, CC Switch, Claude Code Router or OpenRouter, or run them on Ollama, LM Studio and llama.cpp, with budgets.
- [Headless Agents in CI: claude -p, codex exec and the Agent SDKs](https://developertoolkit.ai/en/ecosystem/agent-tools/headless-agents-ci/): Run Claude Code and Codex unattended in CI: claude -p and codex exec flags, schema-bound verdicts, the Agent SDKs, and a PR policy check that fails closed.
- [herdr: The Agent Multiplexer with a Scriptable API](https://developertoolkit.ai/en/ecosystem/agent-tools/herdr-agent-multiplexer/): Install herdr 0.9.1, learn how it really detects blocked agents, and script one agent to run three implementers and a reviewer through its CLI.
- [Beyond the Big Three: OpenCode, Pi, Copilot CLI, Cline, Goose and Other Coding Agents](https://developertoolkit.ai/en/ecosystem/agent-tools/other-coding-agents/): Install lines, status and licences for ten widely used coding agents beyond Claude Code, Codex and Cursor, and a mixed-agent team on one rules file.
- [Running 10 Agents at Once with herdr, Conductor and Worktrees](https://developertoolkit.ai/en/ecosystem/agent-tools/parallel-agents/): Run many coding agents at once: a worktree per issue, ports per worktree, herdr or Conductor to supervise, and a review queue and merge train to land the work.
- [Driving Agents from Your Phone: Remote Control, Happy, CloudCLI and Orca Mobile](https://developertoolkit.ai/en/ecosystem/agent-tools/remote-mobile/): Supervise Claude Code and Codex from a phone with Remote Control, codex remote-control, Happy, CloudCLI or Orca: setup, remote approvals, security, limits.
- [Agent sandboxes compared: container-use, E2B, Daytona, microVMs and Docker](https://developertoolkit.ai/en/ecosystem/agent-tools/sandboxes/): Pick a sandbox for coding agents: isolation model, startup, lifetime and pricing of container-use, E2B, Docker Sandboxes, Modal, Daytona and Coder.
- [tmux for agent fleets: sessions, send-keys, wait-for](https://developertoolkit.ai/en/ecosystem/agent-tools/tmux-for-agent-fleets/): Claude Code, Codex, and Cursor now create their own worktrees. What tmux still owns in a fleet: persistence, visibility, messages, and barriers.
- [Voice Input for Agentic Coding](https://developertoolkit.ai/en/ecosystem/agent-tools/voice-input/): Speak prompts to Claude Code (/voice), Codex, Copilot CLI, and Cursor: set up tap-to-talk, dictate grill-me answers, and verify what the agent heard.
- [Agentic development frameworks compared](https://developertoolkit.ai/en/ecosystem/frameworks/): Compare Superpowers, Spec Kit, OpenSpec, BMAD, GSD, Compound Engineering and more by family, artifacts and context cost, then pilot one on a real feature.
- [Hours of Autonomy: GSD Core, Ralph Loops, /goal and oh-my-claudecode](https://developertoolkit.ai/en/ecosystem/frameworks/autonomous-loops/): Pick and run an unattended agent loop: /goal, the ralph-loop plugin, snarktank and frankbria Ralph, GSD Core, oh-my-claudecode and oh-my-codex, in a sandbox.
- [The BMAD Method: agile roles as agents](https://developertoolkit.ai/en/ecosystem/frameworks/bmad-method/): Run one feature through BMAD's PM, architect and developer agents in Claude Code, Codex and Cursor, and learn when bmad-build's sizing makes the roles worth it.
- [Compound Engineering: The Loop, the Plugin, the Evidence](https://developertoolkit.ai/en/ecosystem/frameworks/compound-engineering/): Install Every's Compound Engineering plugin (3.29.0) in Claude Code, Codex or Cursor, run its learning loop, verify the output and map it onto the ladder.
- [Discipline packs: Pocock skills, gstack, agent-skills, Ponytail and ECC](https://developertoolkit.ai/en/ecosystem/frameworks/discipline-packs/): Compare five discipline packs for coding agents, then pair one 'what to build' pack with Ponytail's 'how much' pushback, verified by tests.
- [Frameworks with audit trails and standards: AI-DLC, Agent OS, Tessl and Kiro-style specs](https://developertoolkit.ai/en/ecosystem/frameworks/enterprise-frameworks/): Run AWS AI-DLC with approval gates and a committed audit trail, and choose between Agent OS, Tessl, cc-sdd and Conductor for standards and spec gates.
- [Everything Claude Code: the largest bundle, used for real](https://developertoolkit.ai/en/ecosystem/frameworks/everything-claude-code/): What Everything Claude Code (ECC) installs, one feature built with it end to end, what to keep and prune, and its ~41.5k-token always-on context cost.
- [GSD: context-engineered phases for solo builders](https://developertoolkit.ai/en/ecosystem/frameworks/gsd/): Run GSD Core's discuss, plan, execute, verify and ship loop on one project in Claude Code, Codex or Cursor, and see what it automates and costs in tokens.
- [gstack: a role-based skill stack for Claude Code](https://developertoolkit.ai/en/ecosystem/frameworks/gstack/): Run gstack's product, eng-manager, reviewer, QA and release skills on one feature, and map each role's output onto the artifact chain.
- [Multi-Agent Harnesses and Catalogues: Ruflo, wshobson/agents, SuperClaude, Task Master and CCPM](https://developertoolkit.ai/en/ecosystem/frameworks/multi-agent-harnesses/): Turn a PRD into a task graph, GitHub issues and parallel agents with CCPM, Task Master and wshobson/agents, and know where Ruflo and SuperClaude fit.
- [OpenSpec: change proposals and living specs](https://developertoolkit.ai/en/ecosystem/frameworks/openspec/): Run OpenSpec's propose, apply and archive loop on an existing codebase in Claude Code, Codex and Cursor, and decide when it beats Spec Kit.
- [One Rules Source for Every Agent: AGENTS.md, Ruler and rulesync](https://developertoolkit.ai/en/ecosystem/frameworks/rules-sync/): Keep one set of agent rules for Claude Code, Codex and Cursor: the AGENTS.md import, Ruler and rulesync, and a CI check that fails on drift.
- [Spec-Driven Frameworks Compared: Spec Kit vs OpenSpec vs BMAD vs Superpowers](https://developertoolkit.ai/en/ecosystem/frameworks/spec-driven-frameworks/): Pick a spec-driven framework for coding agents: Spec Kit, OpenSpec, BMAD, Superpowers and cc-sdd on one feature, with installs, review gates and costs.
- [GitHub Spec Kit: spec-driven development in practice](https://developertoolkit.ai/en/ecosystem/frameworks/spec-kit/): Run GitHub Spec Kit end to end in Claude Code, Codex and Cursor: constitution, specify, plan, tasks, implement and converge, with generated files shown.
- [Superpowers: A Disciplined Development Workflow for Coding Agents](https://developertoolkit.ai/en/ecosystem/frameworks/superpowers/): Install and run Superpowers 6.4.2 in Claude Code, Codex and Cursor: brainstorm, plan, TDD with subagents, review and verified finish, plus its costs and traps.
- [Introduction to Model Context Protocol](https://developertoolkit.ai/en/ecosystem/mcp/): What MCP is in September 2026: spec 2026-07-28, remote OAuth servers, the preview registry, and how to add one server safely in Claude Code, Codex and Cursor.
- [Atlassian Rovo MCP: Jira, Confluence and Bitbucket from Your Agent](https://developertoolkit.ai/en/ecosystem/mcp/atlassian-mcp/): Connect Claude Code, Codex or Cursor to Jira, Confluence and Bitbucket over Atlassian's /v2/mcp server: OAuth or API token, admin controls, traceability.
- [Browser Automation for Agents: Playwright, Chrome DevTools, Browser Use, Stagehand and agent-browser](https://developertoolkit.ai/en/ecosystem/mcp/browser-automation/): Pick the right browser tool for a coding agent: Playwright MCP, Chrome DevTools MCP, agent-browser, dev-browser, Browser Use or Stagehand, matched to the job.
- [Cloud and Platform MCP Servers: AWS, Azure, Google Cloud, Vercel and Stripe](https://developertoolkit.ai/en/ecosystem/mcp/cloud-platform-mcp/): Connect Claude Code, Codex and Cursor to AWS, Azure, Google Cloud, Vercel and Stripe with read-only identities, pinned versions and checks you can prove.
- [Cloudflare MCP: Code Mode and the Domain Servers](https://developertoolkit.ai/en/ecosystem/mcp/cloudflare-mcp/): Connect Cloudflare's Code Mode MCP server and domain servers to Claude Code, Codex and Cursor: OAuth or token, result caps, and a D1 migration workflow.
- [MCP Servers That Understand Your Codebase: Serena, codebase-memory-mcp, Claude Context and Repomix](https://developertoolkit.ai/en/ecosystem/mcp/code-intelligence-mcp/): Give Claude Code, Codex or Cursor symbol-level code navigation: install Serena, codebase-memory-mcp, Claude Context or Repomix and run a safe refactor.
- [Context7: Current Library Docs for Your Agent (MCP, CLI and Skills Mode)](https://developertoolkit.ai/en/ecosystem/mcp/context7/): Set up Context7 in Claude Code, Codex and Cursor, pin library IDs, choose MCP or skills mode, and prove the agent coded against current APIs.
- [Building your own MCP server](https://developertoolkit.ai/en/ecosystem/mcp/custom-mcp-development/): Build an MCP server for an internal API on the v2 SDK, serve spec 2026-07-28 and older clients, test it without reading every line, and ship it.
- [Database MCP Servers: Postgres MCP Pro, DBHub, MCP Toolbox, Supabase, Neon, and MongoDB](https://developertoolkit.ai/en/ecosystem/mcp/database-mcp/): Connect Claude Code, Codex, and Cursor to Postgres, Supabase, Neon, or MongoDB read-only, find slow queries, and ship schema changes through CI.
- [Figma MCP and Design-to-Code in 2026](https://developertoolkit.ai/en/ecosystem/mcp/design-tools-mcp/): Connect Figma's remote MCP server to Claude Code, Codex and Cursor, reuse your real components through Code Connect, and prove the build matches the frame.
- [AI Developer Toolkit MCP Server](https://developertoolkit.ai/en/ecosystem/mcp/developertoolkit-mcp/): Connect Claude Code, Codex or Cursor to this site's guides through a public, read-only MCP endpoint: two tools, no account, no API key.
- [The MCP starter stack for 2026: five servers most teams need](https://developertoolkit.ai/en/ecosystem/mcp/essential-servers/): The five MCP servers most teams need in 2026 (GitHub, Context7, Playwright, Linear or Atlassian, Sentry): install lines for three agents and a bug-to-PR loop.
- [Dev-Server MCPs: Next.js DevTools, MobileBuildMCP and Hugging Face](https://developertoolkit.ai/en/ecosystem/mcp/framework-devtools-mcp/): Connect Next.js DevTools MCP, MobileBuildMCP and Hugging Face MCP to Claude Code, Codex and Cursor so live build, test and runtime errors reach the agent.
- [GitHub MCP Server: Remote, Local, Toolsets and Lockdown Mode](https://developertoolkit.ai/en/ecosystem/mcp/github-mcp/): Set up GitHub's MCP server in Claude Code, Codex and Cursor: remote vs Docker, PAT scopes, toolset URLs, lockdown mode, a CI-fix workflow, and GitLab MCP.
- [Infrastructure MCP: Docker MCP Toolkit, Kubernetes and Terraform](https://developertoolkit.ai/en/ecosystem/mcp/infrastructure-mcp/): Connect Kubernetes and Terraform MCP servers read-only, debug a CrashLoopBackOff, and ship an IaC change from registry lookup to a reviewed HCP plan.
- [One server, many apps: Composio and n8n-mcp](https://developertoolkit.ai/en/ecosystem/mcp/integration-hubs-mcp/): Connect Composio for managed OAuth to many SaaS apps, and use n8n-mcp to build and validate n8n workflows. When one hub beats five vendor servers.
- [MCP best practices: context budget, speed and parallel agents](https://developertoolkit.ai/en/ecosystem/mcp/mcp-best-practices/): Keep MCP servers lean, fast and safe in parallel: measure context cost, cap tool results, pin versions, isolate per-agent profiles, and prove the setup works.
- [MCP Server Connection Issues](https://developertoolkit.ai/en/ecosystem/mcp/mcp-connection-issues/): Fix MCP servers that fail in Claude Code, Codex or Cursor: spawn ENOENT, pending approval, 401s, timeouts and the CLI traps that write a broken server entry.
- [Securing MCP Servers: Scanning, Read-Only Modes and Prompt Injection](https://developertoolkit.ai/en/ecosystem/mcp/mcp-security/): Scan MCP configs and skills with Snyk Agent Scan, turn on read-only modes, contain prompt injection, and run a team MCP approval policy.
- [Mobbin MCP: Real Design Examples for AI Agents](https://developertoolkit.ai/en/ecosystem/mcp/mobbin-mcp/): Connect Claude Code, Codex, or Cursor to Mobbin's library of shipped app screens, research UI patterns before building, and verify the result against them.
- [Debug Production from the Editor: Sentry, Grafana, Datadog, and PostHog MCP](https://developertoolkit.ai/en/ecosystem/mcp/observability-mcp/): Connect Sentry, Grafana, Datadog, and PostHog MCP to Claude Code, Codex, and Cursor read-only, fix the top production error locally, and verify it after deploy.
- [Playwright MCP vs Playwright CLI: Browser Testing for Coding Agents](https://developertoolkit.ai/en/ecosystem/mcp/playwright-mcp/): Choose between Playwright MCP and Playwright CLI with its skill, set --isolated for parallel agents, and turn a bug report into a red-then-green E2E test in CI.
- [Tickets and Docs over MCP: Linear, Jira, Notion and Slack](https://developertoolkit.ai/en/ecosystem/mcp/project-management/): Connect Claude Code, Codex or Cursor to Linear, Jira, Notion and Slack over MCP, then run a ticket-to-PR loop that ends with evidence on the ticket.
- [Reducing MCP token cost: Code Mode, context-mode and CLI-plus-skill routes](https://developertoolkit.ai/en/ecosystem/mcp/reducing-mcp-token-cost/): Cut MCP context cost in Claude Code, Codex and Cursor: context-mode's ctx_execute, Cloudflare Code Mode, GitHub toolsets and CLI-plus-skill swaps.
- [The Reference MCP Servers and When You Don't Need Them](https://developertoolkit.ai/en/ecosystem/mcp/reference-servers/): The seven maintained MCP reference servers, the archived ones and their successors, and a native-tools-first .mcp.json audit for Claude Code, Codex and Cursor.
- [MCP registries and gateways: allowlisting servers for an organization](https://developertoolkit.ai/en/ecosystem/mcp/registry-and-gateways/): Vet MCP servers against the Official MCP Registry, publish an approved catalog, enforce it in Claude Code, Codex and Cursor, and audit calls through a gateway.
- [shadcn/ui MCP Server](https://developertoolkit.ai/en/ecosystem/mcp/shadcn-ui-mcp/): Set up the official shadcn MCP server in Claude Code, Codex and Cursor, pair it with the shadcn skill, and gate registry components with checks, not reading.
- [MCP 2026-07-28: what changed and how to migrate a server](https://developertoolkit.ai/en/ecosystem/mcp/spec-2026-07-28/): MCP 2026-07-28 drops the handshake and sessions and adds server/discover. What breaks in a custom server, how to migrate it, and how to test both eras.
- [Top community MCP servers and how to vet them](https://developertoolkit.ai/en/ecosystem/mcp/top-community-servers/): Community-built MCP servers worth installing in 2026, from Serena and Repomix to DBHub, plus a 15-minute vetting routine before your team trusts one.
- [Top 30 MCP Servers for Software Teams, Ranked (September 2026)](https://developertoolkit.ai/en/ecosystem/mcp/top-mcp-servers/): The 30 MCP servers software teams use most, ranked: official or community, remote or local, each server's read-only switch, and a starter stack per team type.
- [Web Search and Scraping MCP: Firecrawl, Exa, Tavily, Brave and MarkItDown](https://developertoolkit.ai/en/ecosystem/mcp/web-research-mcp/): Pick and install web search, scraping and conversion MCP servers in Claude Code, Codex and Cursor, then turn sources into a cited, checked ADR.
- [AI model comparison for coding agents](https://developertoolkit.ai/en/ecosystem/models/): Coding-agent models, prices and defaults for Claude Code, Codex and Cursor, checked 2026-10-12, and the rule for choosing: default, then effort, then evals.
- [Reading coding-agent benchmarks, and building your own evals](https://developertoolkit.ai/en/ecosystem/models/benchmarks/): What SWE-bench Verified, SWE-bench Pro, Terminal-Bench 4.0 and vendor tables measure and miss, and how to build a 30-task eval set that picks your model.
- [When a new model ships: a 48-hour evaluation playbook](https://developertoolkit.ai/en/ecosystem/models/new-model-playbook/): A 48-hour procedure for a new coding model: pin today's setup, re-run your evals, compare quality, cost and latency, re-tune effort, and roll out per loop.
- [Open-weight and self-hosted models for coding agents](https://developertoolkit.ai/en/ecosystem/models/open-weight/): GLM, Qwen, Kimi, DeepSeek and Mistral models for air-gapped work: licences, which harnesses accept them, how to serve them, and how to measure the gap on your own evals.
- [Measuring Agentic Engineering: Telemetry, Cost, Review, Security and Evals](https://developertoolkit.ai/en/ecosystem/observability/): Measure coding agents in three layers: built-in telemetry, local cost trackers, eval and trace platforms. What to enable first, plus a weekly agent report.
- [What Did the Agents Cost? ccusage, /usage, Monitors and Gateway Budgets](https://developertoolkit.ai/en/ecosystem/observability/agent-cost-tracking/): Track what Claude Code, Codex and Cursor cost: /usage, ccusage, usage monitors, and per-team budgets with LiteLLM, Cloudflare AI Gateway or claude gateway.
- [Security Gates for Agent-Written Code: Semgrep, Gitleaks, TruffleHog, Snyk and Claude Security Review](https://developertoolkit.ai/en/ecosystem/observability/agent-security-gates/): Stop secrets and vulnerable code in agent commits: a Gitleaks pre-commit hook, Semgrep and TruffleHog in CI, and Claude security review on every pull request.
- [OpenTelemetry and Analytics for Claude Code, Codex and Cursor](https://developertoolkit.ai/en/ecosystem/observability/agent-telemetry/): Send Claude Code and Codex telemetry to a local Grafana stack, read the analytics dashboards' limits, and trace commits to sessions with Entire CLI.
- [AI Code Review Bots Compared: Claude Code Review, Codex, Bugbot, CodeRabbit, Greptile and More](https://developertoolkit.ai/en/ecosystem/observability/ai-code-review-bots/): Which AI code review bot runs where: Claude Code Review, codex review, Copilot, Bugbot, CodeRabbit, Greptile and ocr on trigger, config and cost per PR.
- [Evaluating Agents, Prompts and CLAUDE.md Changes: promptfoo, Inspect SWE, Langfuse and Braintrust](https://developertoolkit.ai/en/ecosystem/observability/evals-coding-agents/): A/B test a CLAUDE.md or AGENTS.md change on a fixed task set with promptfoo or Inspect SWE, then trace failing sessions in Langfuse or Braintrust.
- [Plugins and marketplaces in Claude Code, Codex and Cursor](https://developertoolkit.ai/en/ecosystem/plugins/): What a plugin bundles, how the Claude Code, Codex, Cursor and Copilot CLI marketplaces differ, and how a team measures, pins and allowlists plugins.
- [Anthropic's Developer Plugins: code-review, feature-dev, pr-review-toolkit, security-guidance and More](https://developertoolkit.ai/en/ecosystem/plugins/anthropic-dev-plugins/): 14 Anthropic plugins for Claude Code developers: what each does, its context cost, built-in versus plugin names, and a feature-to-PR workflow that holds up.
- [Building and distributing a plugin or a private marketplace](https://developertoolkit.ai/en/ecosystem/plugins/building-plugins/): Build a plugin that bundles a skill, a hook and an MCP server, prove it with validate and eval, version it, and ship it through a private team marketplace.
- [Marketplaces and registries: where plugins, skills, and MCP servers come from](https://developertoolkit.ai/en/ecosystem/plugins/marketplaces-registries/): Which marketplace or registry to use for a plugin, skill, or MCP server in Claude Code, Codex, Cursor, and Copilot, what a listing proves, and how to review it.
- [Persistent Memory for Agents: claude-mem, planning-with-files and MCP Memory Servers](https://developertoolkit.ai/en/ecosystem/plugins/memory-plugins/): Keep a multi-day agent task alive across /clear with planning-with-files, and add claude-mem, the Memory MCP server or basic-memory only where they earn it.
- [Publishing a Private Plugin Marketplace for Your Team](https://developertoolkit.ai/en/ecosystem/plugins/team-marketplace/): Run a private plugin marketplace for Claude Code, Codex and Cursor: repo layout, reserved names, version rule, private-repo auth, CI validation and rollout.
- [The plugins worth installing, with usage examples](https://developertoolkit.ai/en/ecosystem/plugins/top-plugins/): The 20 most-installed Claude Code plugins ranked, with measured context cost, what each can touch, Codex and Cursor availability, and one example each.
- [Introduction to Agent Skills](https://developertoolkit.ai/en/ecosystem/skills/): Agent Skills are SKILL.md folders that Claude Code, Codex, and Cursor load on demand: plugin or portable copy, where each agent reads them, and pinning.
- [agent-browser: letting the agent check the running app](https://developertoolkit.ai/en/ecosystem/skills/agent-browser/): Install the agent-browser CLI and skill in Claude Code, Codex and Cursor, run a browse-and-verify loop, and ship screenshots as pull request evidence.
- [Building and Publishing Your Own Skills](https://developertoolkit.ai/en/ecosystem/skills/building-custom-skills/): Scaffold a SKILL.md with npx skills init, claude plugin init or skill-creator, prove it with validate --strict and plugin eval, then publish and pin it.
- [Code Review Inside the Agent: Skills and Plugins](https://developertoolkit.ai/en/ecosystem/skills/code-review-skills/): Built-in /code-review, the code-review and pr-review-toolkit plugins, Pocock, Superpowers, Trail of Bits and CodeRabbit review skills, and how to chain them.
- [Skills for Context and Token Discipline: caveman, handoff, karpathy-guidelines](https://developertoolkit.ai/en/ecosystem/skills/context-and-token-skills/): Install caveman, handoff and karpathy-guidelines in Claude Code, Codex and Cursor, hand off at 70% context, and resume long tasks without compaction loss.
- [Documents and Writing: Office Skills, doc-coauthoring and writing-guidelines](https://developertoolkit.ai/en/ecosystem/skills/document-and-writing-skills/): Install Anthropic's docx, pdf, pptx and xlsx skills, doc-coauthoring, Vercel writing-guidelines and humanizer, and chain them from RFC draft to published deck.
- [Dr. Skill: Auditing Your Agent's Skill and MCP Loadout](https://developertoolkit.ai/en/ecosystem/skills/drskill/): Use drskill 0.8.1 to see which skills, plugin skills and MCP servers each agent loads, find conflicts and dead weight, and gate the loadout in CI.
- [Matt Pocock's Skills: From grill-me to implement](https://developertoolkit.ai/en/ecosystem/skills/grill-me/): Install Matt Pocock's skills in Claude Code, Codex and Cursor, then run the chain: grill-me, to-spec, to-tickets, implement with tdd, and code-review.
- [Impeccable: a design vocabulary for your AI harness](https://developertoolkit.ai/en/ecosystem/skills/impeccable-design/): Install Impeccable, give your agent a shared design vocabulary, and gate AI-generated UI with its deterministic detector in hooks and CI.
- [Installing, sharing and pinning skills across a team](https://developertoolkit.ai/en/ecosystem/skills/installing-managing/): Install Agent Skills with the skills CLI 1.7.0, pin them to a git ref, share them through the repo, and avoid the traps that install the wrong set.
- [shadcn/improve: Audit With Your Best Model, Execute With a Cheap One](https://developertoolkit.ai/en/ecosystem/skills/shadcn-improve/): Install shadcn/improve, audit a repo with your strongest model, turn findings into self-contained plans, and hand them to a cheaper executor you can verify.
- [Skill Supply-Chain Security](https://developertoolkit.ai/en/ecosystem/skills/skill-security/): Vet third-party Agent Skills before your agent loads them: spot copycat repos, scan SKILL.md with Snyk Agent Scan, read hooks, and enforce a team allowlist.
- [Taste Skill: The Anti-Slop Frontend Skill Library](https://developertoolkit.ai/en/ecosystem/skills/taste-skill/): Install Taste Skill in Claude Code, Codex, or Cursor, steer landing-page generation with its dials and ban list, and verify the result with CI checks.
- [Skills That Make Agents Test and Debug Properly](https://developertoolkit.ai/en/ecosystem/skills/testing-debugging-skills/): Install tdd, diagnosing-bugs, systematic-debugging and verification-before-completion in Claude Code, Codex and Cursor, and prove every fix.
- [The 25 Most-Installed Development-Practice Skills (September 2026)](https://developertoolkit.ai/en/ecosystem/skills/top-practice-skills/): The 25 most-installed practice skills for Claude Code, Codex and Cursor, a starter trio for a new repo, and how to chain them into a verified loop.
- [Best Backend and DevOps Skills: Databases, Auth, Cloud, IaC](https://developertoolkit.ai/en/ecosystem/skills/top-skills-backend/): Vendor skills for Supabase, Neon, Clerk, Better Auth, Cloudflare, AWS, Stripe and Terraform: installs per tool, context cost and a new-service workflow.
- [Skills for Product, Marketing and Knowledge Work](https://developertoolkit.ai/en/ecosystem/skills/top-skills-business/): Marketing Skills, last30days, Obsidian and Google Workspace skills for coding agents: a /pricing CRO audit, a launch checklist, and how to verify the output.
- [Best Frontend Skills: Design, React, Next.js and Mobile](https://developertoolkit.ai/en/ecosystem/skills/top-skills-frontend/): The frontend skills worth installing in 2026 (design, React, Next.js, Expo, Remotion) and a design-to-trace loop that proves the UI works.
- [Official Vendor Skills: Who Publishes What (September 2026)](https://developertoolkit.ai/en/ecosystem/skills/top-skills-official/): Which vendors publish official agent skills, canonical repos and installs for Claude Code, Codex and Cursor, what is not official, and a monthly update chore.
- [Anti-Slop Writing Skills: Unslop, miodkuj, and What the Evals Say](https://developertoolkit.ai/en/ecosystem/skills/unslop/): Find and fix AI tells in docs with unslop's Python scanners as a CI gate, miodkuj for Polish, and humanizer, with what each project's own evals prove.

## Cookbook

- [AI Developer Cookbook](https://developertoolkit.ai/en/cookbook/): Copy-paste recipes for Claude Code, Codex, and Cursor by stack, each paired with the test, type, or build check that proves the agent's output.
- [Backend recipes](https://developertoolkit.ai/en/cookbook/backend-recipes/): Pick the backend recipe for your stack, write its gate commands into AGENTS.md, and prove agent-written services with tests instead of line-by-line review.
- [API Development Patterns](https://developertoolkit.ai/en/cookbook/backend-recipes/api-patterns/): Prompts for Claude Code, Codex, and Cursor that build idempotent POSTs, keyset pagination, and a drift-proof OpenAPI spec, plus the checks that prove them.
- [.NET and C# recipes](https://developertoolkit.ai/en/cookbook/backend-recipes/dotnet-patterns/): Agent recipes for ASP.NET Core, EF Core and xUnit v3 — one AGENTS.md, test-first loops on real Postgres, and analyzers that fail the build, not the review.
- [Elixir/Phoenix Recipes](https://developertoolkit.ai/en/cookbook/backend-recipes/elixir-patterns/): Agent recipes for Phoenix 1.8 and Elixir 1.20: mix precommit as the gate, Tidewave MCP, LiveView streams, OTP tests, Ecto.Multi, Oban and releases.
- [Go Language Patterns](https://developertoolkit.ai/en/cookbook/backend-recipes/go-patterns/): Prompts and gates for agent-written Go services — graceful shutdown, bounded goroutines, sized pgx pools, and race and leak checks you can trust.
- [Java & Spring Boot Patterns](https://developertoolkit.ai/en/cookbook/backend-recipes/java-patterns/): Get Spring Boot 4.1 code from Claude Code, Codex or Cursor that avoids removed APIs, N+1 queries and swallowed errors, proven by Testcontainers and ArchUnit.
- [Node.js/Express Recipes](https://developertoolkit.ai/en/cookbook/backend-recipes/node-patterns/): Prompts and gates for agent-written Node.js services on Express 5: clean shutdown, validation, token rotation, Prisma transactions, queues, and safe logs.
- [PHP Development Patterns](https://developertoolkit.ai/en/cookbook/backend-recipes/php-patterns/): Agent recipes for Laravel 13 and Symfony — Laravel Boost context, tests first, Pint, PHPStan and PHPUnit as the gate, strict Eloquent and safe legacy rewrites.
- [Python Workflow Recipes](https://developertoolkit.ai/en/cookbook/backend-recipes/python-patterns/): Prompts and gates for agent-written Python backends: FastAPI lifespan, Pydantic v2, async SQLAlchemy 2.1, Celery, httpx, structlog, and Django tenant scoping.
- [Ruby on Rails Recipes](https://developertoolkit.ai/en/cookbook/backend-recipes/ruby-rails-patterns/): Agent recipes for Rails 8.1 — generators over hand-written files, RSpec loops, bin/ci as the definition of done, safe migrations and N+1 checks that fail specs.
- [Rust Development Patterns](https://developertoolkit.ai/en/cookbook/backend-recipes/rust-patterns/): Prompts and gates for agent-written Rust services — ownership without clone spam, errors mapped to HTTP, compile-checked SQLx, and clean Tokio shutdown.
- [Serverless Development Patterns](https://developertoolkit.ai/en/cookbook/backend-recipes/serverless-patterns/): Agent recipes for AWS Lambda, Cloudflare Workers and Vercel — idempotent handlers, binding checks, cold-start triage, and tests that prove it.
- [Data Engineering Recipes](https://developertoolkit.ai/en/cookbook/data-recipes/): Copy-paste recipes for dbt models, SQL pipelines, notebooks and data tests with Claude Code, Codex or Cursor, each proven by a dbt build on a dev target.
- [Database recipes](https://developertoolkit.ai/en/cookbook/database-recipes/): Pick the right database recipe for migrations, ORMs, SQL tuning or NoSQL, ground the agent in your real schema, and prove each change on a real engine.
- [Database Migration Patterns](https://developertoolkit.ai/en/cookbook/database-recipes/migration-patterns/): Zero-downtime Postgres migrations with Claude Code, Codex, and Cursor, proven by a Squawk lint gate, a parity query, and a rollback plan for each phase.
- [NoSQL Patterns and Strategies](https://developertoolkit.ai/en/cookbook/database-recipes/nosql-patterns/): Design MongoDB, DynamoDB, Neo4j, and vector data models with Claude Code, Codex, or Cursor from real access patterns, and prove every query with tests.
- [ORM Best Practices](https://developertoolkit.ai/en/cookbook/database-recipes/orm-patterns/): Get Prisma 7 and TypeORM 1.x code from Claude Code, Codex or Cursor that cannot oversell, cause N+1 queries or call a removed API, proven on real Postgres.
- [SQL Optimization Patterns](https://developertoolkit.ai/en/cookbook/database-recipes/sql-patterns/): Tune slow Postgres and MySQL queries with Claude Code, Codex, and Cursor, and prove each index, rewrite, and N+1 fix with plans and parity queries.
- [DevOps & Infrastructure Recipes](https://developertoolkit.ai/en/cookbook/devops-recipes/): Pick the DevOps recipe for Docker, Kubernetes, CI/CD, IaC or monitoring, give the agent your delivery rules, and prove each change with gates.
- [CI/CD Pipeline Patterns](https://developertoolkit.ai/en/cookbook/devops-recipes/ci-cd-pipelines/): Copy-paste recipes that make Claude Code, Codex, and Cursor generate CI/CD pipelines with gates you prove can fail: scans, pinned actions, gated deploys.
- [Docker & Container Patterns](https://developertoolkit.ai/en/cookbook/devops-recipes/docker-patterns/): Recipes for agent-written Dockerfiles, Compose files and image CI with Claude Code, Codex and Cursor, plus a script that proves each image before you merge.
- [Infrastructure as Code Patterns](https://developertoolkit.ai/en/cookbook/devops-recipes/infrastructure-as-code/): Recipes for agent-written Terraform, CloudFormation and Pulumi, with plan-only credentials, a machine-checked plan gate and a human sign-off on destroys.
- [Kubernetes Orchestration Patterns](https://developertoolkit.ai/en/cookbook/devops-recipes/kubernetes-patterns/): Have Claude Code, Codex, or Cursor write Kubernetes manifests and Helm charts, then prove them with kubeconform, server dry-run, and diff gates.
- [Monitoring & Logging Patterns](https://developertoolkit.ai/en/cookbook/devops-recipes/monitoring-logging/): Agent recipes for golden-signal and SLO burn-rate alerts, Alertmanager routing, log-trace correlation and tail sampling, each proven by a machine check.
- [Error Handling Recipes](https://developertoolkit.ai/en/cookbook/error-handling-recipes/): Pick the recipe for debugging, logging, recovery or monitoring, give the agent your error rules, and prove each fix with a check that failed first.
- [Debugging Patterns](https://developertoolkit.ai/en/cookbook/error-handling-recipes/debugging-patterns/): Five agent debugging recipes for intermittent failures, stack traces, memory leaks, races and cross-service bugs, each proven by a check that failed first.
- [Logging Patterns](https://developertoolkit.ai/en/cookbook/error-handling-recipes/logging-patterns/): Agent recipes that turn console.log into structured, correlated, redacted Node.js logs, proven by a log-contract test, a secret canary and a lint gate.
- [Recovery Patterns](https://developertoolkit.ai/en/cookbook/error-handling-recipes/recovery-patterns/): Agent recipes for circuit breakers, retries and fallbacks built on opossum and cockatiel, proven by a contract test that trips the breaker on purpose.
- [Frontend recipes](https://developertoolkit.ai/en/cookbook/frontend-recipes/): Pick the frontend recipe for your framework, give the agent a browser, and prove UI work with type, test, a11y and screenshot gates, not line-by-line review.
- [Angular Development Recipes](https://developertoolkit.ai/en/cookbook/frontend-recipes/angular-patterns/): Copy-paste prompts that get Angular 22 code from Claude Code, Codex or Cursor: signals, Signal Forms, zoneless, SSR, proven by build, Vitest and E2E gates.
- [Next.js Optimization Recipes](https://developertoolkit.ai/en/cookbook/frontend-recipes/nextjs-patterns/): Copy-paste prompts that get Next.js 16 App Router code from Claude Code, Codex or Cursor, with the build, type and Playwright gates that prove it.
- [Nuxt 4 development recipes with AI agents](https://developertoolkit.ai/en/cookbook/frontend-recipes/nuxt-patterns/): Copy-paste prompts that get Nuxt 4 code from Claude Code, Codex or Cursor, with the Nuxt docs MCP server and the type, test and build gates that prove it.
- [React Development Recipes](https://developertoolkit.ai/en/cookbook/frontend-recipes/react-patterns/): Copy-paste prompts for React 19 work in Claude Code, Codex and Cursor: Figma to code, TanStack v9 tables, forms, optimistic UI, and gates.
- [Vue.js Workflow Recipes](https://developertoolkit.ai/en/cookbook/frontend-recipes/vue-patterns/): Copy-paste prompts for Vue 3.5 work in Claude Code, Codex and Cursor: Pinia 4 stores, composables, forms, routes, i18n, and the gates that prove them.
- [Mobile Development](https://developertoolkit.ai/en/cookbook/mobile-development/): Mobile recipes for Claude Code, Codex, and Cursor: pick Expo, React Native, Flutter, or native, install the stack's skills, and verify on simulators.
- [Expo Development Patterns](https://developertoolkit.ai/en/cookbook/mobile-development/expo/): Expo SDK 57 with Claude Code, Codex, and Cursor: Expo skills and MCP, Expo Router auth gates, a fingerprint-gated EAS pipeline, and safe OTA updates.
- [Flutter Development Patterns](https://developertoolkit.ai/en/cookbook/mobile-development/flutter/): Flutter with Claude Code, Codex, and Cursor: the official Dart and Flutter plugin, Riverpod 3 codegen, go_router, Dio, and a gate that checks every change.
- [React Native and Flutter UI Recipes](https://developertoolkit.ai/en/cookbook/mobile-development/mobile-patterns/): 12 copy-paste agent prompts for React Native and Flutter UI, pinned to current package majors, each with the device evidence that proves it works.
- [Native iOS and Android Recipes](https://developertoolkit.ai/en/cookbook/mobile-development/native-ios-android/): Swift/SwiftUI and Kotlin/Compose with an agent: one build-and-test script per platform, simulator and emulator loops, fast builds, and UI-test evidence.
- [React Native Development Patterns](https://developertoolkit.ai/en/cookbook/mobile-development/react-native/): React Native with Claude Code, Codex, and Cursor: offline-first state, FlashList v2, biometric gates, release-build debugging, and the gates that prove it.

## Lead a team

- [Team: leading a team that ships with agents](https://developertoolkit.ai/en/teams/): For tech leads: roll agents out to a whole team, share one harness, keep the review queue moving, and bring skeptics, seniors and juniors along.
- [Rolling out coding agents to a team](https://developertoolkit.ai/en/teams/adopt/): For tech leads: the order a team rollout of coding agents runs in, which page covers each step, and the evidence that proves the rollout works.
- [Adoption roadmap for one repository: ladder transitions per loop](https://developertoolkit.ai/en/teams/adopt/adoption-roadmap/): Move one repository's delivery loops up the autonomy ladder one rung at a time, with the repo changes, gate evidence, prompts and rollback rule for each step.
- [Migrating between Codex, Cursor, and Claude Code](https://developertoolkit.ai/en/teams/adopt/from-codex/): Move a repo between Codex, Claude Code, and Cursor: one AGENTS.md, the built-in import commands, MCP config per tool, and a parity run that proves it.
- [Adding Claude Code or Codex alongside GitHub Copilot](https://developertoolkit.ai/en/teams/adopt/from-copilot/): Keep GitHub Copilot and add Claude Code or Codex: one AGENTS.md, shared skills and MCP, a two-week pilot, and the same CI gates on every agent's PR.
- [Migrating from traditional IDEs](https://developertoolkit.ai/en/teams/adopt/from-traditional-ide/): Move from VS Code, JetBrains, or Vim to Cursor, Claude Code, or Codex: keep your editor setup, add one instructions file, and prove each agent diff with gates.
- [Migrating from Devin Desktop (formerly Windsurf)](https://developertoolkit.ai/en/teams/adopt/from-windsurf/): Move a Windsurf or Devin Desktop repo to Claude Code, Codex or Cursor: map rule triggers, turn workflows into skills, re-add MCP, prove the rules apply.
- [Project conversion playbook](https://developertoolkit.ai/en/teams/adopt/project-conversion/): Convert an existing repo for Claude Code, Codex, and Cursor: one AGENTS.md drafted from the real code, thin adapters, CI checks, and a before/after pilot.
- [Team onboarding and adoption, loop by loop](https://developertoolkit.ai/en/teams/adopt/team-adoption/): For tech leads: onboard a team onto coding agents one loop at a time, with a loop owner, a shared harness, the effective-use measure and rollback rules.
- [Team collaboration: shared context and rules](https://developertoolkit.ai/en/teams/adopt/team-collaboration/): Give every engineer's Claude Code, Codex or Cursor agent the same team context: shared rules, a review-to-rule loop, committed plans and proof they loaded.
- [Workflow transformation: rebuilding feature delivery around agents](https://developertoolkit.ai/en/teams/adopt/workflow-transformation/): For tech leads: redesign the ticket-to-merge loop so agents draft plan, code and tests while people own intent, acceptance and risk, with gates that prove it.
- [Shaping a backlog for agents](https://developertoolkit.ai/en/teams/agent-ready-backlog/): Which tickets agents take: an eligibility test (oracle, blast radius, reversibility), slicing, a ticket template, and four lanes from interactive to human-only.
- [Growing junior developers when agents write the code](https://developertoolkit.ai/en/teams/junior-developers/): For tech leads and CTOs: what juniors still practise by hand, review-to-learn sessions, spec writing as training, and the risk of hiring no juniors.
- [Keeping a team current when the tools ship weekly](https://developertoolkit.ai/en/teams/keeping-current/): For tech leads: a weekly release-watch rota, a trial-to-harness graduation path for new agent features, and date-stamped team docs that fail CI when stale.
- [Running the review queue when agents open the pull requests](https://developertoolkit.ai/en/teams/review-queue/): For tech leads: balance agent PR arrivals against review capacity with WIP limits, PR size budgets, risk lanes, and reviewer load.
- [Bringing skeptics and senior engineers along](https://developertoolkit.ai/en/teams/skeptics-and-seniors/): Treat senior skepticism as verification gaps: seniors design the checks and run a measured pilot on their own tasks, with METR's results read honestly.
- [Helping the team stop reading every diff](https://developertoolkit.ai/en/teams/trust-transfer/): Trust transfer for teams: shadow review, sampled review, then evidence-only per loop, with entry evidence, rollback rules, and answers to accountability fears.
- [Upskilling a team for agentic engineering](https://developertoolkit.ai/en/teams/upskilling/): For tech leads and CTOs: a curriculum per ladder level, katas from your own repo, review-to-learn sessions and an AI-literacy record for Article 4.

## Tech Lead Scorecard

- [Tech Lead Scorecard answer key](https://developertoolkit.ai/en/lead-scorecard-guide/): Each of the Tech Lead Scorecard's 25 questions mapped to the page that moves it, the evidence a 3-point answer needs, and a four-week plan for one team.

## Engineering organization

- [Engineering organization: running coding agents at company scale](https://developertoolkit.ai/en/org/): The CTO's hub for coding agents at company scale: operating model, autonomy gates, security, measurement, spend and hiring, plus a baseline to adopt.
- [Agent identity, credentials and secrets](https://developertoolkit.ai/en/org/agent-identity-and-secrets/): Give each coding agent its own short-lived, least-privilege identity: OIDC in CI, scoped MCP OAuth, secrets out of context, hardened Actions and revocation.
- [When an agent causes an incident](https://developertoolkit.ai/en/org/agent-incidents/): Contain an agent incident by revoking its identity and pausing its loops, attribute it through provenance, name the failed control, and turn it into an eval.
- [The agent threat model: prompt injection, data and blast radius](https://developertoolkit.ai/en/org/agent-threat-model/): The lethal trifecta, injection through issues, PRs and web pages, credential scope, exfiltration and the MCP, skill and plugin supply chain, mapped to OWASP.
- [ISO/IEC 42001, NIST AI RMF and SOC 2 evidence from the agent pipeline](https://developertoolkit.ai/en/org/ai-management-standards/): A control-to-evidence map showing how the evidence bundle, gates, evals, telemetry and provenance answer ISO/IEC 42001, NIST AI RMF and SOC 2 auditors.
- [Career ladders and performance reviews when output is cheap](https://developertoolkit.ai/en/org/career-ladders/): Rewrite engineering ladders around outcomes, specs, verification and harness work; keep PR and token counts out of reviews and telemetry out of surveillance.
- [Running coding agents on a corporate network](https://developertoolkit.ai/en/org/corporate-environment/): Get Claude Code, Codex and Cursor working behind a corporate proxy, TLS inspection, SSO and an egress allowlist, delivered by MDM and proven by a smoke test.
- [AI usage cost governance](https://developertoolkit.ai/en/org/cost-governance/): Govern Claude Code, Codex, and Cursor spend: per-team telemetry, spend limits, a model and effort policy, and a monthly review tied to accepted work.
- [The DORA AI Capabilities Model: a self-assessment](https://developertoolkit.ai/en/org/dora-ai-capabilities/): Score your organization on the seven capabilities of DORA's AI Capabilities Model, with evidence per score and a link to the page that builds each one.
- [The EU AI Act for companies building software with agents](https://developertoolkit.ai/en/org/eu-ai-act/): What the AI Act asks of a company using Claude Code, Codex or Cursor after the Digital Omnibus, what it leaves to vendors, and when your product changes it.
- [CRA, NIS2 and DORA-EU: EU software regulation for teams using agents](https://developertoolkit.ai/en/org/eu-software-regulation/): What the Cyber Resilience Act, NIS2, DORA-EU and GDPR ask of a company whose software is written by agents, and the controls that produce the evidence.
- [Governance and autonomy: put humans at the gates](https://developertoolkit.ai/en/org/governance-autonomy/): Assign agent autonomy by risk class, not confidence: guardrails during work, gates before merge and production, named approvers, and controls you rehearse.
- [Hiring and interviewing for agentic engineering](https://developertoolkit.ai/en/org/hiring/): Interview loops with coding agents allowed: work samples that test spec writing, verification design and review judgment, scored with anchored rubrics.
- [Legal and IP questions about agent-written code](https://developertoolkit.ai/en/org/legal-and-ip/): Ownership, license contamination, vendor indemnities, data terms and client clauses for agent-written code: a checklist for counsel. Terms checked 2026-09-26.
- [Avoiding lock-in: portable context, skills and pipelines](https://developertoolkit.ai/en/org/lock-in-and-portability/): Which agent assets move between Claude Code, Codex and Cursor, which stay behind, and an exit-rehearsal checklist that measures your real switching cost.
- [Enforcing one policy across every coding agent you run](https://developertoolkit.ai/en/org/managed-policy/): Managed settings for Claude Code, Codex, Cursor and GitHub Copilot: one policy for models, MCP servers, plugins and permissions, versioned and audited.
- [DORA, SPACE, DX Core 4 and AI measurement when agents write the code](https://developertoolkit.ai/en/org/metrics-frameworks/): Which delivery metrics survive agent-written code and which break, canonical AI metric definitions, and a minimal panel per org level.
- [Where the model runs: gateways, cloud routes, residency and zero retention](https://developertoolkit.ai/en/org/model-hosting/): Anthropic API, Bedrock, Google Cloud, Foundry, a gateway or self-hosting: where coding-agent inference runs, which region it stays in, and what ZDR covers.
- [The operating model: who owns the harness, the gates and the evals](https://developertoolkit.ai/en/org/operating-model/): A RACI for agent-built software: owners for rules, skills, hooks, MCP, agent identities, evals, loops and the production gate, plus a one-page charter.
- [Designing a pilot that proves something](https://developertoolkit.ai/en/org/pilot-design/): Design a 4–8 week AI coding agent pilot: a system baseline, matched concurrent cohorts, confounders, sample size and a decision rule signed before week one.
- [The agent platform team: running the harness as a product](https://developertoolkit.ai/en/org/platform-team/): Charter, backlog, service levels and product metrics for an agent platform team that runs policy, skills, hooks, evals, environments and telemetry.
- [Data privacy and enterprise policies for coding agents](https://developertoolkit.ai/en/org/privacy-data-handling/): Decide what data may reach a coding agent: four data classes, a register of approved services, vendor retention, context controls and tests that prove them.
- [Buying AI coding tools: the security, legal and data questionnaire](https://developertoolkit.ai/en/org/procurement/): A 40-question vendor questionnaire for AI coding tools (retention, training, ZDR, region, SSO/SCIM, audit, indemnity) and how to verify each answer.
- [Agentic engineering in regulated industries](https://developertoolkit.ai/en/org/regulated-industries/): Separation of duties, change-management evidence and audit trails when agents write and review code in finance, health and the public sector.
- [Security standards and compliance for coding agents](https://developertoolkit.ai/en/org/security-compliance/): An eight-control security baseline that gets Claude Code, Codex and Cursor through SOC 2, GDPR and HIPAA review, with control tests that prove it holds.
- [An AI usage policy engineers will follow](https://developertoolkit.ai/en/org/usage-policy/): An acceptable-use template for coding agents: data classes, approved routes, disclosure, review duties and prohibited actions, each marked enforced or trust.

## Strategy & business

- [Strategy: AI-native engineering for business leaders](https://developertoolkit.ai/en/strategy/): The business decisions behind agentic engineering: economics, business case, org design, roadmap and board reporting, with the evidence standard behind them.
- [Reporting AI engineering to the board](https://developertoolkit.ai/en/strategy/board-reporting/): A quarterly one-page board report on AI engineering: autonomy level per critical loop, cost per accepted change, incident trend and a five-row risk register.
- [Software built outside engineering](https://developertoolkit.ai/en/strategy/builders-beyond-engineering/): How analysts, ops, and domain experts build internal tools with agents and app builders: where it pays off, how prototypes graduate, where governance stops.
- [Building the business case for agentic engineering](https://developertoolkit.ai/en/strategy/business-case/): A decision-memo template for funding agentic engineering: four options, a measured baseline, full cost, a break-even figure, stop gates and risks.
- [The economics of agent-built software: cost per accepted change](https://developertoolkit.ai/en/strategy/economics/): Cost per accepted change: licenses, usage, CI, review, rework and incidents over merged, non-reverted changes. The ROI method, with a worked example.
- [Leading people through the change](https://developertoolkit.ai/en/strategy/leading-the-change/): What to tell engineers and the company when agents write the code: a one-page AI stance, honest answers on jobs, and a sequence that keeps quality from dipping.
- [How teams, roles and headcount change shape](https://developertoolkit.ai/en/strategy/org-design/): Org design for agentic engineering: size teams by review capacity, staff harness, eval and factory roles, and plan headcount without multipliers.
- [Product management when build time collapses](https://developertoolkit.ai/en/strategy/product-management/): When agents build in hours, product managers write intent.md and acceptance criteria, run outcome roadmaps, and gate prototypes out of production.
- [AI-native delivery for software houses and agencies](https://developertoolkit.ai/en/strategy/services-firms/): Pricing, client disclosure, margin, staffing, and contract clauses on IP, data, and warranties for software houses and agencies that use coding agents.
- [AI coding success stories: the case studies that hold up](https://developertoolkit.ai/en/strategy/success-stories/): Stripe, Microsoft and Anthropic case studies of coding agents, with dated sources, the counter-evidence, a vetting checklist and a pattern to reproduce.
- [The organization-wide roadmap: from pilots to an agentic delivery system](https://developertoolkit.ai/en/strategy/transformation-roadmap/): A 12-month plan to move an engineering organization from AI pilots to agentic delivery, with stop/go gates written as autonomy-ladder transitions per loop.

## Developer Scorecard

- [Developer Scorecard answer key](https://developertoolkit.ai/en/developer-scorecard-guide/): Each of the Developer Scorecard's 25 questions mapped to the page that moves the answer, with the evidence a 3-point answer needs and the fixes to make first.
- [Use hooks as deterministic guardrails](https://developertoolkit.ai/en/developer-scorecard-guide/agent-hooks/): Four layered hooks for Claude Code and Codex: protect paths, block risky commands, lint each edit, and refuse to stop with secrets or failing tests.
- [Agent skills — turn policy into a tested workflow](https://developertoolkit.ai/en/developer-scorecard-guide/agent-skills/): Turn one team policy into an owned SKILL.md that Claude Code, Codex and Cursor load when relevant, with acceptance runs that prove it fires and holds.
- [Scoped AI incident triage](https://developertoolkit.ai/en/developer-scorecard-guide/ai-on-call-tag/): Run an incident agent under its own read-only identity: it gathers evidence and drafts the timeline, while a named human owns mitigation and recovery.
- [Run a bounded PR review-fix loop](https://developertoolkit.ai/en/developer-scorecard-guide/auto-pr-workflow/): Let an agent triage PR review comments and failed CI, fix reproduced causes, rerun gates, and stop for named human sign-off, with commands and prompts.
- [AGENTS.md and CLAUDE.md — concise repository context](https://developertoolkit.ai/en/developer-scorecard-guide/claude-md-context/): Write one short AGENTS.md core, wire Claude Code, Codex and Cursor to it, and prove with /context and codex debug prompt-input which rules each agent loaded.
- [Continuous evals — regression-test the agent harness in CI](https://developertoolkit.ai/en/developer-scorecard-guide/continuous-evals/): Run real repository tasks in CI on every change to CLAUDE.md, AGENTS.md, skills, hooks, CLI or model, gate on repeated pass rates, and add each incident.
- [Deterministic anomaly detection and scoped diagnosis](https://developertoolkit.ai/en/developer-scorecard-guide/control-band-detection/): Detect production anomalies with versioned, replay-tested alert rules, then hand each firing alert to a read-only agent that drafts a sourced diagnosis.
- [Scoped subagents — delegate bounded work, not responsibility](https://developertoolkit.ai/en/developer-scorecard-guide/custom-subagents/): Define explorer and verifier subagents in Claude Code, Codex and Cursor with enforced tool limits, a fixed output contract and a measured payoff.
- [Agent-driven browser verification — prove the user flow](https://developertoolkit.ai/en/developer-scorecard-guide/e2e-agent-verification/): Have the agent run each acceptance criterion in a real browser, keep reproducible evidence, and promote critical flows into deterministic Playwright tests.
- [Run parallel agents in isolated worktrees](https://developertoolkit.ai/en/developer-scorecard-guide/git-worktrees/): Run two to four agent tasks at once in Git worktrees with Claude Code, Codex, or Cursor: ports, local config, proof per stream, and cleanup that loses nothing.
- [Configure review agents for layered pull-request review](https://developertoolkit.ai/en/developer-scorecard-guide/layered-pr-review/): Set up Claude Code, Codex and Cursor review agents from one REVIEW.md: separate passes, evidence-backed findings, a CI gate, and named human sign-off.
- [Model routing by evidence, not brand](https://developertoolkit.ai/en/developer-scorecard-guide/model-routing/): Route each class of agent work to a model and effort level your own evals picked: a dated routing table, per-tool config, and a before-and-after test.
- [Choose a primary AI engineering harness](https://developertoolkit.ai/en/developer-scorecard-guide/primary-ai-tool/): Pick Claude Code, Codex, or Cursor as your primary harness with a trial on your own tasks: a scoring sheet, verification gates, and a decision record.
- [Production approval as a system boundary](https://developertoolkit.ai/en/developer-scorecard-guide/production-approval-gate/): Stop agents deploying unvetted code: separate identities, no standing production credentials, protected branches and a named human approving the deploy job.
- [Rehearsed rollback with human production authority](https://developertoolkit.ai/en/developer-scorecard-guide/rollback-pipeline/): Make rollback one rehearsed command: a versioned contract, a protected job, recovery checks, and agents that prepare and verify without production access.
- [Scheduled security scans with evidence and PR gates](https://developertoolkit.ai/en/developer-scorecard-guide/scheduled-security-scans/): Run pinned scanners and a read-only agent pass weekly, keep versioned evidence, triage by fingerprint, and ship fixes only through test-first PRs.
- [Size an AI plan from measured workload](https://developertoolkit.ai/en/developer-scorecard-guide/subscription-plan-fit/): Pick the cheapest Claude, ChatGPT, or Cursor plan that finishes your real agent work: a usage log, a quarterly review, and a dated decision record.
- [Visual acceptance before frontend implementation](https://developertoolkit.ai/en/developer-scorecard-guide/ui-design-mock/): Turn intent.md into an inspectable UI mock, record a signed visual acceptance file, and check the built screen against it before merge.

## CTO Scorecard

- [CTO Scorecard answer key](https://developertoolkit.ai/en/cto-scorecard-guide/): The CTO Scorecard's Level 1–4 bands explained, and each of its 25 questions mapped to the page that moves the answer and the evidence a top answer needs.
- [AI in CI/CD: a bounded server-side loop](https://developertoolkit.ai/en/cto-scorecard-guide/ai-in-cicd/): A CTO policy for agents in CI/CD: trusted triggers, a read-only agent job, deterministic gates, and a named human who merges. Claude Code and Codex workflows.
- [AI metrics panel — measure accepted delivery](https://developertoolkit.ai/en/cto-scorecard-guide/ai-metrics-panel/): CTO Scorecard Q22 answer key: what each metric tick is worth, which three make a panel that works, a metric card to adopt, and how to verify the numbers.
- [Change provenance and risk routing](https://developertoolkit.ai/en/cto-scorecard-guide/ai-pr-labeling/): Route every pull request by what it touches, recorded in the evidence bundle, not by who wrote it. Keep AI provenance for measurement and audit only.
- [AI tooling roadmap — the portfolio-item template for capability bets](https://developertoolkit.ai/en/cto-scorecard-guide/ai-tooling-roadmap/): CTO Scorecard Q24: a portfolio-item template for each AI tooling bet on the transformation roadmap, with a hypothesis, full cost, stop gate and review date.
- [Developer onboarding — prove one safe workflow](https://developertoolkit.ai/en/cto-scorecard-guide/dev-onboarding-time/): CTO Scorecard Q19: time a repeatable onboarding fixture from clean setup to a verified sample change, with no shared secrets and no undocumented help.
- [E2E policy: browser evidence for every user-visible change](https://developertoolkit.ai/en/cto-scorecard-guide/e2e-policy/): A CTO policy for UI changes made by agents: risk-classed browser evidence, retained traces, and critical flows promoted to deterministic Playwright CI tests.
- [Internal MCP servers — build only the missing interface](https://developertoolkit.ai/en/cto-scorecard-guide/internal-mcp-servers/): CTO Scorecard Q7: build an internal MCP server only for a measured access gap, with a narrow contract, an owner, two-era tests, and retirement criteria.
- [Knowledge sharing — version evidence, not tricks](https://developertoolkit.ai/en/cto-scorecard-guide/knowledge-sharing/): CTO Scorecard Q20: route each lesson from a failed run, review or incident to one owned, versioned artifact, prove agents find it, and retire it on time.
- [MCP security — authorize each identity and tool](https://developertoolkit.ai/en/cto-scorecard-guide/mcp-security/): CTO Scorecard Q8: enforce a reviewed MCP allowlist in managed config, authorize each tool, gate writes, log every call, and test with injection fixtures.
- [Plan policy: accepted artifacts before risky execution](https://developertoolkit.ai/en/cto-scorecard-guide/plan-mode-policy/): A plan-gate policy for sensitive changes: accepted intent, spec and plan merged first, a CI check on protected paths, and a named code owner who approves.
- [AI tooling ROI — the evidence behind a full-score answer](https://developertoolkit.ai/en/cto-scorecard-guide/roi-measurement/): CTO Scorecard Q23 answer key: what matched-cohort ROI evidence contains, how to move up one answer, and where the site's one ROI method lives.
- [Shared agent rules — one core, tested adapters](https://developertoolkit.ai/en/cto-scorecard-guide/shared-agent-rules/): CTO Scorecard Q5: one AGENTS.md core, thin Claude Code, Codex and Cursor adapters, CI checks and fresh-session probes that prove every agent loads it.
- [Shared hooks governance: reviewed runtime controls](https://developertoolkit.ai/en/cto-scorecard-guide/shared-hooks-governance/): Govern shared agent hooks like production code: a contract, pinned versions, fixtures, managed distribution, staged rollout, audit logs and a tested rollback.
- [Shared skills: tested procedural capability](https://developertoolkit.ai/en/cto-scorecard-guide/shared-skills/): Run shared agent skills like code: a skill contract, one source for Claude Code, Codex, and Cursor, eval fixtures, a pinned team marketplace and usage evidence.
- [Team adoption — measure effective workflow use](https://developertoolkit.ai/en/cto-scorecard-guide/team-adoption-rate/): CTO Scorecard Q1: measure AI adoption as eligible engineers completing approved workflows, with accepted-outcome, quality and control evidence.
- [Team accounts — ownership, lifecycle, and data terms](https://developertoolkit.ai/en/cto-scorecard-guide/team-billing/): CTO Scorecard Q3: bind AI coding tool logins to your organization, run joiner/mover/leaver controls, and reconcile seats and spend every month.
- [Team parallelism at Level 3 — isolate work and cap the queue](https://developertoolkit.ai/en/cto-scorecard-guide/team-parallelism-tier2/): For tech leads and CTOs: run parallel agent tasks as a Level 3 team workflow with isolated state, per-class caps, integration owners and queue limits.
- [Team PR review automation policy — evidence before approval](https://developertoolkit.ai/en/cto-scorecard-guide/team-pr-review-automation/): An org policy for AI pull request review: risk lanes, authoritative checks, blocking rules, who approves, and metrics that prove reviewers earn their cost.
- [Prototype policy — graduate by risk and evidence](https://developertoolkit.ai/en/cto-scorecard-guide/team-vibe-coding-policy/): CTO Scorecard Q16: a prototype policy you can adopt, with four exposure classes, automated graduation triggers, and a six-criterion gate before production.
- [Unattended agent runs at Level 4–5 — bounded recurring work](https://developertoolkit.ai/en/cto-scorecard-guide/tier3-overnight-runs/): For CTOs and tech leads: run scheduled and event-triggered agent work with a task-class contract, a dispatch cap, a run report and a human merge gate.
- [Tooling policy — approved workflows and measured exceptions](https://developertoolkit.ai/en/cto-scorecard-guide/tooling-policy/): CTO Scorecard Q2: an approved-workflow matrix, dated service records, enforced default tools, and time-bounded exceptions that end in a decision.
- [Vendor risk management — test continuity, not logos](https://developertoolkit.ai/en/cto-scorecard-guide/vendor-risk-management/): CTO Scorecard Q25: keep AI-assisted delivery running when a vendor changes a model, limit, route or term, with a tested fallback and a recovery drill.

## Reference & help: Reference

- [Appendices](https://developertoolkit.ai/en/reference/): Lookup pages for Claude Code, Codex and Cursor: commands, config files, shortcuts and terms, plus how to check them against the version you run.
- [Command Reference Cheatsheet](https://developertoolkit.ai/en/reference/command-reference/): Claude Code, Codex and Cursor commands checked against the installed CLIs: flags, slash commands, headless runs, review commands and stale flags to remove.
- [Configuration reference](https://developertoolkit.ai/en/reference/config-reference/): Where Cursor, Claude Code and Codex read project instructions: .cursor/rules, CLAUDE.md, AGENTS.md and config.toml, with loading rules and checks.
- [A–Z Reference: AI Development Terms](https://developertoolkit.ai/en/reference/glossary/): A to Z reference of AI development terms: what each means, its name in Claude Code, Codex and Cursor, and how 21 names for working with AI differ.
- [Keyboard shortcuts for Claude Code, Codex and Cursor](https://developertoolkit.ai/en/reference/keyboard-shortcuts/): The keys that stop, rewind, plan and inspect agent work in Claude Code 2.1.283, Codex CLI 0.157.1 and Cursor, how to remap them, and what breaks in tmux.

## Reference & help: Help & updates

- [Additional Resources](https://developertoolkit.ai/en/resources/): Where to go when Claude Code, Codex or Cursor breaks, confuses you or changes: triage steps, doctor commands, and the FAQ, troubleshooting and changelog pages.
- [Community Resources](https://developertoolkit.ai/en/resources/community/): Where Cursor, Claude Code, and Codex maintainers answer, where skills, plugins, and MCP servers are shared, and how to vet community fixes before adopting them.
- [Frequently Asked Questions](https://developertoolkit.ai/en/resources/faq/): Short, checked answers on Claude Code, Codex, and Cursor: default models, plan prices, privacy, permissions, review, MCP, skills, and usage limits.
- [Provide Feedback](https://developertoolkit.ai/en/resources/feedback/): File Claude Code, Codex, and Cursor bug reports maintainers can reproduce, route feature requests and security issues, and report mistakes in this guide.
- [Troubleshooting guide for Claude Code, Codex and Cursor](https://developertoolkit.ai/en/resources/troubleshooting/): Find which layer broke in Claude Code, Codex or Cursor: install, login, usage limits, ignored rules, context drift, MCP or lost work. Then prove the fix.
- [What's New on AI Developer Toolkit](https://developertoolkit.ai/en/resources/whats-new/): The Claude Code, Codex and Cursor changes that affect your agent setup as of 12 October 2026, with what to do about each, and every guide this site shipped, month by month.

## Free pages (no account required)

- [Compare AI Coding Tools](https://developertoolkit.ai/en/compare/): Cursor, Claude Code and Codex side by side: interface, agents, models, safety and price, with a plain verdict on each pairing and links into the docs.
- [Cursor vs Claude Code vs Codex](https://developertoolkit.ai/en/compare/best-ai-coding-tools/): Cursor, Claude Code and Codex compared on interface, agents and safety, with dated prices where the docs have them and a plain answer on where to start.
- [Cursor vs Claude Code](https://developertoolkit.ai/en/compare/cursor-vs-claude-code/): Cursor and Claude Code compared on interface, agent capability and unattended runs. A side-by-side table, a plain verdict, and the case for running both.
- [Claude Code vs Codex](https://developertoolkit.ai/en/compare/claude-code-vs-codex/): Claude Code and OpenAI Codex compared on surfaces, models, approval modes and price: 33 hook events against 12, and where each one takes work from.
- [Cursor vs Codex](https://developertoolkit.ai/en/compare/cursor-vs-codex/): Cursor vs OpenAI Codex on interface, integrations and unattended runs: one puts AI in your editor, the other an agent in GitHub, Slack and the cloud.
- [Cursor vs GitHub Copilot](https://developertoolkit.ai/en/compare/cursor-vs-github-copilot/): Cursor and GitHub Copilot compared: Copilot's cloud agent starts from a GitHub issue, Cursor's agent in a VS Code-based editor. See where each one fits.
- [AI Coding Glossary: Agentic vs Vibe Coding](https://developertoolkit.ai/en/glossary/): Thirty-four terms for AI coding agents: agentic engineering against vibe coding, plus tool concepts from MCP to plan mode, each defined for quoting.
- [What are Agent Skills?](https://developertoolkit.ai/en/glossary/agent-skills/): Agent Skills are a portable, open standard for extending AI coding agents. How they install, which agents support them, and how they differ from MCP.
- [What is agentic engineering?](https://developertoolkit.ai/en/glossary/agentic-engineering/): Agentic engineering is the name Andrej Karpathy popularised in February 2026 for coordinating fallible but powerful coding agents without dropping quality.
- [What is AGENTS.md?](https://developertoolkit.ai/en/glossary/agents-md/): AGENTS.md is the repo config file Codex reads to learn how agents should behave. Where it goes, what belongs in it, and how it differs from CLAUDE.md.
- [What is CLAUDE.md?](https://developertoolkit.ai/en/glossary/claude-md/): CLAUDE.md is the file Claude Code reads automatically for project context. Where it goes, what belongs in it, and how it relates to AGENTS.md.
- [What is a context window?](https://developertoolkit.ai/en/glossary/context-window/): A context window is the text a model holds at once, in tokens. What fills it, its size in Claude Code and Codex, and when to compact, clear or delegate.
- [What are Git worktrees?](https://developertoolkit.ai/en/glossary/git-worktrees/): Git worktrees check out several branches at once, each in its own directory. Why parallel AI agents need them, and how Codex uses them for isolated tasks.
- [What is headless mode?](https://developertoolkit.ai/en/glossary/headless-mode/): Headless mode runs an AI coding agent with no human in the loop, for CI and automation. The commands in Claude Code and Codex, and what to guard first.
- [What are hooks?](https://developertoolkit.ai/en/glossary/hooks/): Hooks fire before or after an agent’s tool calls, defined in .claude/settings.json. What they are used for, and why they beat asking an agent to behave.
- [What is MCP (Model Context Protocol)?](https://developertoolkit.ai/en/glossary/mcp/): MCP is the open standard for connecting AI coding agents to external tools and live data. How Claude Code, Codex and Cursor each add an MCP server.
- [What is plan mode?](https://developertoolkit.ai/en/glossary/plan-mode/): Plan mode makes an AI agent write a structured plan before it edits anything. How to enter it in Claude Code, and how Cursor and Codex expose it.
- [What is a sandbox?](https://developertoolkit.ai/en/glossary/sandbox/): A sandbox limits what an AI agent’s commands can touch. How it differs from approval, and how Claude Code, Codex and Cursor each implement it.
- [What are slash commands?](https://developertoolkit.ai/en/glossary/slash-commands/): Slash commands trigger built-in and custom actions in AI coding agents. Which Claude Code and Codex ship, and why typing / is the only reliable inventory.
- [What is a software factory?](https://developertoolkit.ai/en/glossary/software-factory/): A software factory: agents pull work from a queue and verification gates decide what merges. Level 5 of the autonomy ladder.
- [What is a sub-agent?](https://developertoolkit.ai/en/glossary/subagents/): A sub-agent is a separate AI instance that handles one subtask in its own context window. How Cursor, Claude Code and Codex run them, and when it pays off.
- [What is agent orchestration?](https://developertoolkit.ai/en/glossary/agent-orchestration/): Agent orchestration: coordinating several coding agents on one task. Anthropic’s orchestrator-worker pattern, Gas Town, and the link to vibe coding.
- [What is agentic coding?](https://developertoolkit.ai/en/glossary/agentic-coding/): Agentic coding: an AI agent plans, writes, runs and tests code in a loop. How it differs from vibe coding and from agentic engineering, with dated sources.
- [What is agentic software development?](https://developertoolkit.ai/en/glossary/agentic-software-development/): Agentic software development: agents across the whole lifecycle, humans accountable at the gates. Who used the name and how it differs from vibe coding.
- [What are agentic workflows?](https://developertoolkit.ai/en/glossary/agentic-workflows/): Agentic workflows: LLM applications that work in several passes, a name Andrew Ng popularised in 2024. How they differ from agents and vibe coding.
- [What are AI coding agents?](https://developertoolkit.ai/en/glossary/ai-coding-agents/): AI coding agents read a codebase, edit files, run commands and check results in a loop. How Claude Code, Codex and Cursor differ, with check dates.
- [What is AI engineering?](https://developertoolkit.ai/en/glossary/ai-engineering/): AI engineering is building applications on foundation models, a role swyx popularised in 2023. How it differs from agentic engineering and vibe coding.
- [What is AI pair programming?](https://developertoolkit.ai/en/glossary/ai-pair-programming/): AI pair programming is working beside a coding assistant and reading each suggestion as it appears, a phrase GitHub Copilot popularised in 2021.
- [What is AI SDLC? Also called agentic SDLC](https://developertoolkit.ai/en/glossary/ai-sdlc/): AI SDLC, also called agentic SDLC: a lifecycle where agents draft each stage and named humans own the gates. No single coiner. Versus vibe coding.
- [What is AI-assisted coding?](https://developertoolkit.ai/en/glossary/ai-assisted-coding/): AI-assisted coding is the umbrella term for using LLMs and agents to help write software. Where vibe coding and agentic engineering sit inside it.
- [What is AI-DLC? AWS’s AI-driven lifecycle](https://developertoolkit.ai/en/glossary/ai-dlc/): AI-DLC is AWS’s AI-Driven Development Lifecycle: bolts, Mob Elaboration, Mob Construction. Open-sourced in 2025. Versus vibe coding.
- [What is AI-driven development?](https://developertoolkit.ai/en/glossary/ai-driven-development/): AI-driven development: a generic phrase for AI-led work with no owner. AWS’s split into assisted, autonomous and driven, versus vibe coding.
- [What is AI-native development?](https://developertoolkit.ai/en/glossary/ai-native-development/): AI-native development is a team operating model built around AI, not added to the old process. Who introduced the term and how it differs from vibe coding.
- [What is augmented coding?](https://developertoolkit.ai/en/glossary/augmented-coding/): Augmented coding is Kent Beck’s 2025 name for AI-assisted programming that still cares about the code and its tests. How it differs from vibe coding.
- [What is compound engineering? Every’s method](https://developertoolkit.ai/en/glossary/compound-engineering/): Compound engineering is Every’s method for making each change leave a coding agent better prepared for the next: who coined it, the loop, and vibe coding.
- [What is context engineering?](https://developertoolkit.ai/en/glossary/context-engineering/): Context engineering is deciding what a coding agent sees at each step: who named it, how it differs from prompt engineering and from vibe coding.
- [What is harness engineering?](https://developertoolkit.ai/en/glossary/harness-engineering/): Harness engineering turns repeated agent mistakes into permanent controls. Who named it, and how it differs from context engineering and vibe coding.
- [What is prompt engineering?](https://developertoolkit.ai/en/glossary/prompt-engineering/): Prompt engineering: writing and refining instructions for an AI model. Why context engineering now gets the attention, and how it differs from vibe coding.
- [What is spec-driven development?](https://developertoolkit.ai/en/glossary/spec-driven-development/): Spec-driven development has a coding agent build from a reviewed spec: who used the term first, its three levels and how it differs from vibe coding.
- [What is vibe coding?](https://developertoolkit.ai/en/glossary/vibe-coding/): Vibe coding is accepting AI-written code without reading it, coined by Andrej Karpathy on 2 February 2025. How it differs from agentic engineering.
- [What is vibe engineering?](https://developertoolkit.ai/en/glossary/vibe-engineering/): Vibe engineering is Simon Willison’s October 2025 name for accountable, professional work with AI. How it differs from vibe coding and agentic engineering.
- [AI Coding by Role](https://developertoolkit.ai/en/for/): What an AI coding agent changes for backend, frontend, mobile and DevOps engineers, solo builders, tech leads and CTOs, plus a free scorecard per role.
- [AI coding tools for backend developers](https://developertoolkit.ai/en/for/backend-developers/): How AI coding agents change backend work: API and database patterns, and recipes for Node, Python, Go, Rust, Java, PHP, Elixir and serverless.
- [AI coding tools for frontend developers](https://developertoolkit.ai/en/for/frontend-developers/): How AI coding agents fit frontend work, and framework recipes for React, Vue, Angular, Next.js and Nuxt — plus which tool suits visual, iterative editing.
- [AI coding tools for mobile developers](https://developertoolkit.ai/en/for/mobile-developers/): How AI coding agents fit mobile work, with recipes for React Native, Expo and Flutter, and where the build-and-test loop changes what an agent can verify.
- [AI coding tools for DevOps and platform engineers](https://developertoolkit.ai/en/for/devops-engineers/): AI coding agents in CI and the guardrails that make it safe: an exact command allowlist, a sandbox, headless mode, plus Docker, Kubernetes and IaC recipes.
- [AI coding tools for solo builders](https://developertoolkit.ai/en/for/solo-builders/): Shipping alone with AI coding agents: no reviewer means the guardrails have to be structural. What to set up first, and which tool to start with.
- [AI coding tools for tech leads](https://developertoolkit.ai/en/for/engineering-leads/): Rolling AI coding agents out to a team: shared standards, review that scales, and the seat maths. What changes when everyone is running an agent.
- [AI coding tools for CTOs and founders](https://developertoolkit.ai/en/for/ctos/): Adopting AI coding agents across an engineering org: governance, cost visibility, security and the numbers to ask for instead of a productivity promise.

## Languages

- English: https://developertoolkit.ai/en/
- Polish: https://developertoolkit.ai/pl/
- Polish AI index (llms-pl.txt): https://developertoolkit.ai/llms-pl.txt

## Full documentation for AI systems

- [MCP server](https://developertoolkit.ai/mcp): Model Context Protocol endpoint (Streamable HTTP, no auth). Tools: `search` over 1100+ articles, `fetch` for one article's full markdown.
- [All English docs, single file](https://developertoolkit.ai/llms-full.txt): 13.1 MB — prefer the per-section files below if your context is limited
- [All Polish docs, single file](https://developertoolkit.ai/llms-full-pl.txt)
- [Autonomy Ladder (free, no account required) (section file)](https://developertoolkit.ai/llms/ladder.txt)
- [Start here (free, no account required) (section file)](https://developertoolkit.ai/llms/start.txt)
- [Cursor (section file)](https://developertoolkit.ai/llms/cursor-ide.txt)
- [Claude Code (section file)](https://developertoolkit.ai/llms/claude-code.txt)
- [Codex (section file)](https://developertoolkit.ai/llms/codex.txt)
- [Workflows & method: Method (section file)](https://developertoolkit.ai/llms/method.txt)
- [Workflows & method: Workflows, all tools (section file)](https://developertoolkit.ai/llms/workflows.txt)
- [Ecosystem & comparisons: Choose a tool (section file)](https://developertoolkit.ai/llms/comparison.txt)
- [Ecosystem & comparisons: Models, MCP, skills and agent tools (section file)](https://developertoolkit.ai/llms/ecosystem.txt)
- [Cookbook (section file)](https://developertoolkit.ai/llms/cookbook.txt)
- [Lead a team (section file)](https://developertoolkit.ai/llms/teams.txt)
- [Tech Lead Scorecard (section file)](https://developertoolkit.ai/llms/lead-scorecard-guide.txt)
- [Engineering organization (section file)](https://developertoolkit.ai/llms/org.txt)
- [Strategy & business (section file)](https://developertoolkit.ai/llms/strategy.txt)
- [Developer Scorecard (section file)](https://developertoolkit.ai/llms/developer-scorecard-guide.txt)
- [CTO Scorecard (section file)](https://developertoolkit.ai/llms/cto-scorecard-guide.txt)
- [Reference & help: Reference (section file)](https://developertoolkit.ai/llms/reference.txt)
- [Reference & help: Help & updates (section file)](https://developertoolkit.ai/llms/resources.txt)

## Optional

- [Compare AI coding tools](https://developertoolkit.ai/en/compare/)
- [Pricing (machine-readable, USD)](https://developertoolkit.ai/pricing.md)
- [Pricing (machine-readable, PLN)](https://developertoolkit.ai/pricing-pl.md)
- [Polish index for AI systems](https://developertoolkit.ai/llms-pl.txt)
- [Sitemap](https://developertoolkit.ai/sitemap-index.xml)