# AI Developer Toolkit > Master AI-powered development with Cursor, Claude Code, and Codex. Educational platform with 400+ tutorials covering setup, advanced techniques, cost control, and production workflows. AI Developer Toolkit (developertoolkit.ai) is a subscription-based learning platform for professional developers. Content is bilingual (English and Polish) and organized by tool and workflow. ## Introduction - [Welcome to the AI Development Revolution](https://developertoolkit.ai/en/introduction/): The definitive guide to shipping production code with Cursor, Claude Code, and Codex - [How to Use This Guide](https://developertoolkit.ai/en/introduction/how-to-use-this-guide/): Learning path recommendations and navigation map based on your experience level and goals - [Quick Wins in Your First 24 Hours](https://developertoolkit.ai/en/introduction/quick-wins/): Proven techniques that deliver real value from AI coding tools starting in the next 30 minutes - [What Makes Them Different](https://developertoolkit.ai/en/introduction/what-makes-them-different/): Beyond autocomplete - how Cursor, Claude Code, and Codex work as true AI pair programmers - [Why AI Coding Tools? The Paradigm Shift](https://developertoolkit.ai/en/introduction/why-ai-coding-tools/): Understanding the fundamental change in how software gets built with AI coding assistants ## Tool Comparison - [Tool Comparison Overview](https://developertoolkit.ai/en/comparison/): Comprehensive analysis of Cursor, Claude Code, and Codex to help you choose the right AI coding tools - [Alternative IDEs and Agent Shells](https://developertoolkit.ai/en/comparison/alternative-ides-and-orchestrators/): A survey of the tools you can run Claude Code, Codex, and Cursor Agent inside -- herdr, Conductor, Zed via ACP, Nimbalyst, Emdash, Sculptor, Warp -- and how to pick one that outlives the churn. - [Token and Credit Usage Optimization Strategies](https://developertoolkit.ai/en/comparison/cost-optimization/): Practical techniques to maximize productivity while controlling costs across Cursor, Claude Code, and Codex - [Cursor vs Claude Code -- When to Use Which](https://developertoolkit.ai/en/comparison/cursor-vs-claude-code/): In-depth comparison of IDE-first vs CLI-first AI development approaches with real workflow examples - [Detailed Three-Tool Capability Comparison](https://developertoolkit.ai/en/comparison/feature-matrix/): Comprehensive side-by-side feature matrix comparing Cursor, Claude Code, and Codex across agent capabilities, models, and pricing - [Moving from Other Tools -- Decision Framework](https://developertoolkit.ai/en/comparison/migration-guide/): Structured migration paths for switching to Cursor, Claude Code, or Codex from other AI coding tools - [Cost Comparison and ROI Across All Three Tools](https://developertoolkit.ai/en/comparison/pricing-analysis/): Verified pricing, current rate cards, and editable cost scenarios for Cursor, Claude Code, and Codex - [From Plain Chat to Integrated Development](https://developertoolkit.ai/en/comparison/vs-chatgpt/): When to use ordinary ChatGPT conversation versus ChatGPT Codex, Cursor, or Claude Code for repository-aware software development. - [Codex vs Cursor and Claude Code -- Strengths and Trade-offs](https://developertoolkit.ai/en/comparison/vs-codex/): How OpenAI Codex's multi-surface approach compares to Cursor's IDE-first and Claude Code's CLI-first philosophies, with honest trade-offs. - [Cursor & Claude Code vs GitHub Copilot](https://developertoolkit.ai/en/comparison/vs-github-copilot/): Understanding the fundamental capability gap between autocomplete-era and agent-era AI coding tools - [Cursor, Claude Code, and Codex vs Windsurf](https://developertoolkit.ai/en/comparison/vs-windsurf/): Honest comparison of the three leading AI coding tools against Windsurf (now Devin Desktop), covering models, agents, and trade-offs. ## Claude Code - [Claude Code](https://developertoolkit.ai/en/claude-code/): Master CLI-first AI development with Claude Code - from terminal basics to advanced hooks, automation, and enterprise workflows - [Advanced Techniques](https://developertoolkit.ai/en/claude-code/advanced-techniques/): Deep dives into hooks, custom commands, memory management, enterprise proxies, LLM gateways, GitHub Actions, and cost monitoring for Claude Code power users - [Agent View: claude agents](https://developertoolkit.ai/en/claude-code/advanced-techniques/agent-view/): Dispatch and manage many Claude Code background sessions from one screen with the claude agents dashboard introduced in v2.1.139 - [CI/CD Integration & Automation](https://developertoolkit.ai/en/claude-code/advanced-techniques/ci-cd-integration/): Integrate Claude Code into your continuous integration pipelines with GitHub Actions, headless mode, and automated workflows - [Enterprise Cost Control](https://developertoolkit.ai/en/claude-code/advanced-techniques/cost-control/): Control Claude Code spend at scale with /cost, /stats, OpenTelemetry metrics, model routing, and budget guardrails — without slowing your team down. - [Creating Custom Commands](https://developertoolkit.ai/en/claude-code/advanced-techniques/custom-commands/): Build reusable slash commands and subagents that encode your team's best practices into repeatable Claude Code workflows - [Custom Subagents](https://developertoolkit.ai/en/claude-code/advanced-techniques/custom-subagents/): Create specialized AI assistants that work alongside Claude Code for task-specific expertise, each with its own context window and tool access - [Development Container Setup](https://developertoolkit.ai/en/claude-code/advanced-techniques/devcontainer-setup/): Create isolated, reproducible development environments with Claude Code using Dev Containers, Codespaces, and remote development - [Dynamic Workflows & ultracode](https://developertoolkit.ai/en/claude-code/advanced-techniques/dynamic-workflows/): Orchestrate tens to hundreds of subagents from a script Claude writes and you can rerun — and let ultracode decide when a task warrants one. Claude Code v2.1.154+, research preview. - [Enterprise Integration and Security](https://developertoolkit.ai/en/claude-code/advanced-techniques/enterprise-integration/): Deploy Claude Code at scale with managed settings, compliance policies, team-wide configuration, and organization-level controls - [GitHub Actions Integration](https://developertoolkit.ai/en/claude-code/advanced-techniques/github-actions/): Run Claude Code in CI/CD pipelines with GitHub Actions for automated code reviews, PR generation, issue triage, and scheduled maintenance - [Goal Workflows with /goal](https://developertoolkit.ai/en/claude-code/advanced-techniques/goal-workflows/): Set a completion condition with /goal and let Claude Code keep working across turns until the condition is verifiably met - [Hooks System Mastery](https://developertoolkit.ai/en/claude-code/advanced-techniques/hooks-automation/): Build deterministic guardrails with Claude Code hooks -- block dangerous commands, auto-format code, inject context, and automate quality checks at every lifecycle event - [LLM Gateway Configuration](https://developertoolkit.ai/en/claude-code/advanced-techniques/llm-gateway/): Route Claude Code through AWS Bedrock, Google Vertex AI, LiteLLM, and custom API gateways for enterprise control and compliance - [Claude Code Memory System](https://developertoolkit.ai/en/claude-code/advanced-techniques/memory-system/): Master the CLAUDE.md hierarchy, auto memory, project rules, and imports to control exactly what Claude knows at every scope level - [Usage Monitoring and Cost Optimization](https://developertoolkit.ai/en/claude-code/advanced-techniques/monitoring-costs/): Track Claude Code usage with OpenTelemetry, manage team costs, optimize token consumption, and build dashboards for organization-wide visibility - [Performance Tuning & Optimization](https://developertoolkit.ai/en/claude-code/advanced-techniques/performance-tuning/): Maximize Claude Code's speed and efficiency through context optimization, intelligent model selection, and workflow patterns - [Proxy and VPN Configuration](https://developertoolkit.ai/en/claude-code/advanced-techniques/proxy-configuration/): Configure Claude Code for corporate networks, HTTP proxies, VPN tunnels, and custom certificate authorities - [Slash Commands Mastery](https://developertoolkit.ai/en/claude-code/advanced-techniques/slash-commands-mastery/): Complete reference for every Claude Code slash command, keyboard shortcut, and session management pattern -- from daily essentials to hidden power moves - [20 Real-World CLI Scenarios](https://developertoolkit.ai/en/claude-code/lessons/): Master Claude Code through battle-tested workflows that ship production code from the terminal - [REST and GraphQL APIs via Claude Code](https://developertoolkit.ai/en/claude-code/lessons/api-development/): Scaffold API endpoints with validation, auth middleware, and error handling -- then test them with curl without leaving the terminal - [System Design with Claude Code](https://developertoolkit.ai/en/claude-code/lessons/architecture/): Use Claude Code for architectural analysis, design document generation, dependency mapping, and technical decision-making -- all from the terminal - [Task Automation with Claude Code](https://developertoolkit.ai/en/claude-code/lessons/automation/): Turn repetitive development tasks into one-command workflows using Claude Code's headless mode, hooks, custom commands, and shell scripting - [Pipeline Configuration Using Claude Code](https://developertoolkit.ai/en/claude-code/lessons/ci-cd/): Design and generate CI/CD pipelines with Claude Code -- from GitHub Actions to GitLab CI, with test parallelization, caching, and automated Claude-powered reviews - [Understanding Large Codebases via CLI](https://developertoolkit.ai/en/claude-code/lessons/codebase-analysis/): Onboard to unfamiliar codebases in minutes instead of days using Claude Code's exploration and sub-agent capabilities - [Docker and Kubernetes Setup via CLI](https://developertoolkit.ai/en/claude-code/lessons/containerization/): Use Claude Code to generate production-grade Dockerfiles, Docker Compose stacks, Kubernetes manifests, and Helm charts from your project structure - [Database Operations from the CLI](https://developertoolkit.ai/en/claude-code/lessons/database-work/): Design schemas, generate migrations, write complex queries, and seed test data -- all from Claude Code's terminal workflow - [CLI Debugging Workflow](https://developertoolkit.ai/en/claude-code/lessons/debugging/): Pipe errors directly into Claude Code, trace execution across files, and fix bugs in minutes that used to take hours - [Deployment Automation with Claude Code](https://developertoolkit.ai/en/claude-code/lessons/deployment/): Use Claude Code to script zero-downtime deployments, generate rollback procedures, and automate multi-environment releases from your terminal - [Documentation Generation with Claude Code](https://developertoolkit.ai/en/claude-code/lessons/documentation/): Generate JSDoc, OpenAPI specs, and architecture docs from your actual codebase with hooks that keep them in sync - [Deep Reasoning for Feature Design](https://developertoolkit.ai/en/claude-code/lessons/feature-planning/): Use Plan Mode and extended thinking to transform vague requirements into detailed, implementable feature plans - [From Plan to Working Code](https://developertoolkit.ai/en/claude-code/lessons/implementation/): Execute multi-file implementations with Claude Code's explore-plan-implement-commit cycle while keeping changes reviewable and correct - [Third-Party Integrations via CLI](https://developertoolkit.ai/en/claude-code/lessons/integrations/): Use Claude Code to build, test, and debug third-party API integrations -- from payment providers to email services to OAuth flows - [Database and Code Migrations](https://developertoolkit.ai/en/claude-code/lessons/migrations/): Use Claude Code to plan and execute zero-downtime database migrations, framework upgrades, and large-scale code transformations from the terminal - [Observability Setup via CLI](https://developertoolkit.ai/en/claude-code/lessons/monitoring/): Use Claude Code to instrument your application with structured logging, distributed tracing, and alerting -- all generated and configured from the terminal - [Performance Analysis from the Terminal](https://developertoolkit.ai/en/claude-code/lessons/performance/): Use Claude Code to find slow queries, profile API endpoints, optimize bundle sizes, and generate benchmarks -- all without leaving your terminal - [Starting New Projects from the Terminal](https://developertoolkit.ai/en/claude-code/lessons/project-init/): Bootstrap full-stack applications with Claude Code -- from empty directory to running dev server in under ten minutes - [Project Setup & Initialization](https://developertoolkit.ai/en/claude-code/lessons/project-setup/): Master Claude Code for rapid project bootstrapping and intelligent code generation, with verify steps and copy-paste prompts that keep scaffolds production-ready - [Large-Scale Refactoring from the Terminal](https://developertoolkit.ai/en/claude-code/lessons/refactoring/): Rename across 200 files, migrate patterns codebase-wide, and restructure modules using fan-out patterns and headless mode - [Security Scanning with Claude Code](https://developertoolkit.ai/en/claude-code/lessons/security-audit/): Run security audits from your terminal -- dependency scanning, OWASP vulnerability detection, secret leak prevention, and hardening prompts you can use today - [Test Generation and Execution via CLI](https://developertoolkit.ai/en/claude-code/lessons/testing/): Generate test suites that match your existing patterns, run them after every change, and close coverage gaps from the terminal - [Claude Code Productivity Patterns](https://developertoolkit.ai/en/claude-code/productivity-patterns/): Battle-tested workflows for terminal productivity, prompt engineering, batch operations, script automation, IDE coordination, debugging, code review, and deployment with Claude Code - [Batch Operations](https://developertoolkit.ai/en/claude-code/productivity-patterns/batch-operations/): Patterns for large-scale code changes -- rename 200 files, update 50 imports, migrate an API version across a monorepo with Claude Code - [Debugging Workflows in Claude Code](https://developertoolkit.ai/en/claude-code/productivity-patterns/debugging-workflows/): Systematic debugging from the terminal -- error trace analysis, bisection, log parsing, and the prompts that find root causes fastest with Claude Code - [Deployment Patterns](https://developertoolkit.ai/en/claude-code/productivity-patterns/deployment-patterns/): Streamline deployments with Claude Code -- pre-deploy validation, changelog generation, release notes, and rollback assistance - [Efficiency Hacks](https://developertoolkit.ai/en/claude-code/productivity-patterns/efficiency-hacks/): Time-saving Claude Code techniques that add up to hours saved per week -- output tricks, context management, workflow shortcuts, and patterns from power users - [IDE + CLI Coordination](https://developertoolkit.ai/en/claude-code/productivity-patterns/ide-coordination/): Seamlessly integrate Claude Code CLI with VS Code, Cursor, Neovim, and JetBrains for split-screen workflows that leverage both interfaces - [Multi-File Workflows](https://developertoolkit.ai/en/claude-code/productivity-patterns/multi-file-workflows/): Coordinate complex changes across many files with Claude Code — plan-first prompts, dependency tracing, safe refactors, worktree parallelism, and recovery when a multi-file edit goes sideways. - [Performance Optimization for Claude Code](https://developertoolkit.ai/en/claude-code/productivity-patterns/performance-optimization/): Cut Claude Code token costs without losing quality — scope context with /context and --add-dir, lean on automatic prompt caching, pick the right model, and batch work to reduce round trips. - [Prompt Engineering for Claude Code](https://developertoolkit.ai/en/claude-code/productivity-patterns/prompt-engineering/): Advanced prompting strategies that turn vague requests into precise code changes -- plan mode, effort levels, structured prompts, and context priming - [Refactoring Patterns](https://developertoolkit.ai/en/claude-code/productivity-patterns/refactoring-patterns/): Test-first refactoring with Claude Code: extract methods, replace conditionals with polymorphism, modernize legacy callbacks, and split fat services without breaking behavior. - [Automated Code Reviews](https://developertoolkit.ai/en/claude-code/productivity-patterns/review-automation/): Implement CLI-driven code review workflows with Claude Code -- pre-commit checks, PR analysis, dependency auditing, and quality gates - [Script Automation](https://developertoolkit.ai/en/claude-code/productivity-patterns/script-automation/): Turn Claude Code workflows into reusable scripts with print mode, headless automation, cron jobs, and pre-commit hooks - [Terminal Mastery](https://developertoolkit.ai/en/claude-code/productivity-patterns/terminal-mastery/): Deep dive into terminal productivity with Claude Code -- tmux sessions, multi-pane workflows, shell integration, and the terminal setup used by power users - [Testing Integration](https://developertoolkit.ai/en/claude-code/productivity-patterns/testing-integration/): Build production test suites with Claude Code, Cursor, and Codex: TDD loops, integration and E2E tests, fixes for flaky suites, and CI prompts you can paste in. - [Claude Code Quick Start: Zero to Productive in 2 Hours](https://developertoolkit.ai/en/claude-code/quick-start/): Complete setup guide to go from installing Claude Code to shipping your first feature, including authentication, configuration, CLAUDE.md, MCP servers, and production workflows. - [Authentication: API Keys, Subscriptions, and SSO](https://developertoolkit.ai/en/claude-code/quick-start/authentication/): Connect Claude Code to your Anthropic account using a Claude Max subscription, API key, enterprise SSO, or cloud provider credentials. - [Configuration: Permissions, Models, and YOLO Mode](https://developertoolkit.ai/en/claude-code/quick-start/configuration/): Configure Claude Code's permission system, model selection, auto-approve behavior, and settings hierarchy for your workflow. - [Deep Reasoning: Extended Thinking and Effort Levels](https://developertoolkit.ai/en/claude-code/quick-start/deep-reasoning/): Use Claude Code's extended thinking and effort levels for deeper analysis on complex architecture decisions, debugging puzzles, and multi-system interactions. - [Building Your First Feature with Claude Code](https://developertoolkit.ai/en/claude-code/quick-start/development-workflow/): Walk through a complete development cycle from ticket to PR using Claude Code as your pair programmer, with real prompts and workflow patterns. - [Error Recovery: Handling Failures and Getting Unstuck](https://developertoolkit.ai/en/claude-code/quick-start/error-recovery/): Recover from broken edits, stuck sessions, cascading test failures, and context overload using Claude Code's checkpoints, undo system, and session management. - [Initialize Your First Project](https://developertoolkit.ai/en/claude-code/quick-start/first-project/): Set up Claude Code on any project with a well-structured CLAUDE.md, the memory hierarchy, @path imports, and the /init and # workflows so Claude keeps your conventions across sessions. - [IDE Integration: VS Code, JetBrains, and Beyond](https://developertoolkit.ai/en/claude-code/quick-start/ide-integration/): Set up Claude Code inside VS Code, JetBrains IDEs, and other editors with the official extensions for a seamless coding workflow. - [Installing Claude Code](https://developertoolkit.ai/en/claude-code/quick-start/installation/): Install the Claude Code CLI on macOS, Linux, or Windows in under 10 minutes with the native installer, Homebrew, or WinGet. - [MCP Setup: Connecting External Tools](https://developertoolkit.ai/en/claude-code/quick-start/mcp-setup/): Set up Model Context Protocol servers to give Claude Code access to GitHub, Sentry, databases, Slack, and other external tools. - [PRD to Plan to Todo: Structured Development in Claude Code](https://developertoolkit.ai/en/claude-code/quick-start/prd-workflow/): Turn product requirements into structured implementation plans and tracked task lists using Claude Code's planning workflow. - [Project Initialization: CLAUDE.md and Project Context](https://developertoolkit.ai/en/claude-code/quick-start/project-initialization/): Set up CLAUDE.md files, modular rules, and auto memory to give Claude Code deep understanding of your codebase conventions and architecture. - [Version Control: Git Integration and PR Workflow](https://developertoolkit.ai/en/claude-code/quick-start/version-control/): Use Claude Code to manage branches, write commit messages from diffs, resolve merge conflicts, create pull requests, and run parallel sessions with git worktrees. - [100 Essential Claude Code Tips for Modern Development](https://developertoolkit.ai/en/claude-code/tips-tricks/): Master Claude Code with this comprehensive collection of tips for setup, workflow optimization, large codebase management, and team collaboration - [Advanced Claude Code Techniques](https://developertoolkit.ai/en/claude-code/tips-tricks/advanced-techniques/): Tune extended thinking with effort levels, wire up real MCP servers, build a custom MCP tool, automate PR reviews with GitHub Actions, and run isolated parallel work with worktrees. - [CLAUDE.md Optimization: Tips 16-25](https://developertoolkit.ai/en/claude-code/tips-tricks/claude-md-optimization/): Master effective CLAUDE.md files for persistent memory and project context in Claude Code, with copy-paste prompts to audit, bootstrap, and tighten them. - [Command Line Mastery: Tips 26-35](https://developertoolkit.ai/en/claude-code/tips-tricks/command-line/): Essential Claude Code CLI commands, slash commands, headless automation, and keyboard shortcuts — with copy-paste prompts power users rely on daily. - [What Claude Code Can Do That You Haven't Tried](https://developertoolkit.ai/en/claude-code/tips-tricks/features-you-havent-tried/): Field notes from Gui Ferreira's NDC AI 2026 talk - ~40 underused Claude Code features across one-time setup, your daily loop, extensibility, and work beyond code. - [Large Codebase Management: Tips 36-50](https://developertoolkit.ai/en/claude-code/tips-tricks/large-codebase/): Strategies for navigating, understanding, and modifying enterprise-scale codebases with Claude Code, from million-line monorepos to microservices. - [Performance and Cost Management: Tips 66-75](https://developertoolkit.ai/en/claude-code/tips-tricks/performance-cost/): Optimize token usage, manage costs effectively, and maximize performance with Claude Code - [Claude Code Setup & Configuration](https://developertoolkit.ai/en/claude-code/tips-tricks/setup-configuration/): Essential setup steps, IDE integration, permission configuration, and initial project structure for Claude Code - [Team Collaboration: Tips 86-95](https://developertoolkit.ai/en/claude-code/tips-tricks/team-collaboration/): Share CLAUDE.md, .mcp.json, custom commands, and permission policies so your whole team gets consistent, safe Claude Code workflows. - [Troubleshooting and Best Practices: Tips 96-100](https://developertoolkit.ai/en/claude-code/tips-tricks/troubleshooting/): Recover when Claude Code goes sideways — safe permission rules, frequent reverts, interrupting cleanly, and de-overengineering prompts. - [Workflow Optimization for Claude Code](https://developertoolkit.ai/en/claude-code/tips-tricks/workflow-optimization/): Treat Claude Code as your primary interface with message queuing, auto memory, and reusable commands so you ship features without re-explaining context all day. - [Staying Current with Claude Code](https://developertoolkit.ai/en/claude-code/version-management/): Manage Claude Code versions, control auto-updates, pin releases for teams, and track the model milestones through Fable 5 so an outdated CLI never silently breaks your workflow. - [Beta Features and Early Access](https://developertoolkit.ai/en/claude-code/version-management/beta-features/): How to access, test, and give feedback on Claude Code's beta and research-preview features - agent view, /goal workflows, agent teams, fast mode, and the Figma Dev Mode MCP server. - [Claude Code Version History](https://developertoolkit.ai/en/claude-code/version-management/changelog/): Complete changelog documenting Claude Code's evolution from preview to production - [Claude Code Upgrade Procedures](https://developertoolkit.ai/en/claude-code/version-management/upgrade-procedures/): Best practices and step-by-step guides for upgrading Claude Code safely across different environments ## Cursor IDE - [Cursor IDE: The AI Code Editor](https://developertoolkit.ai/en/cursor-ide/): Master Cursor for AI-powered software development. From setup to advanced agent workflows, learn how to ship production code faster with intelligent AI assistance. - [Advanced Cursor Techniques](https://developertoolkit.ai/en/cursor-ide/advanced-techniques/): Master-level strategies for production-grade Cursor workflows that go beyond the basics - [Agent Modes Deep Dive](https://developertoolkit.ai/en/cursor-ide/advanced-techniques/agent-modes-deep-dive/): When to use Agent, Ask, Plan, and Debug mode in Cursor -- and the mode-switching patterns that produce the best results - [Automation Workflows: AI-Powered Development Pipelines](https://developertoolkit.ai/en/cursor-ide/advanced-techniques/automation-workflows/): Turn Cursor's headless agent into pre-commit checks, CI reviewers, and scheduled maintenance bots that ship stable code, not just prototypes. - [Checkpoints and Branching Strategies](https://developertoolkit.ai/en/cursor-ide/advanced-techniques/checkpoints-branching/): Use Cursor checkpoints and git branching together for safe, reversible experimentation on complex features - [Building Custom MCP Servers: Extend Cursor with Your Tools](https://developertoolkit.ai/en/cursor-ide/advanced-techniques/custom-mcp-servers/): Use Cursor's agent to scaffold, test, and ship a custom MCP server that connects your Postgres database and internal APIs directly into the editor. - [Custom Rules and Templates](https://developertoolkit.ai/en/cursor-ide/advanced-techniques/custom-rules-templates/): Build a .cursor/rules/ library that encodes domain knowledge, coding standards, and workflow automation - [Large Codebase Strategies](https://developertoolkit.ai/en/cursor-ide/advanced-techniques/large-codebase-strategies/): Working effectively with Cursor in codebases exceeding 100,000 lines: rules, scoped prompts, context management, and indexing strategies. - [Multi-Repo Workflows](https://developertoolkit.ai/en/cursor-ide/advanced-techniques/multi-repo-workflows/): Give Cursor cross-repo context with multi-root workspaces, contract rules, and a contract-first workflow for microservices and polyrepos. - [Performance Optimization for Cursor](https://developertoolkit.ai/en/cursor-ide/advanced-techniques/performance-optimization/): Tuning Cursor's indexing, memory, and extension settings for instant responses in large projects - [Privacy and Security in Cursor](https://developertoolkit.ai/en/cursor-ide/advanced-techniques/privacy-security/): Enterprise security configuration, privacy mode, and audit practices for Cursor in regulated environments - [Team Collaboration](https://developertoolkit.ai/en/cursor-ide/advanced-techniques/team-collaboration/): Shared rules, team commands, and workflows that scale AI-assisted development across your organization - [Token Management](https://developertoolkit.ai/en/cursor-ide/advanced-techniques/token-management/): Advanced strategies for optimizing context usage, controlling costs, and getting more from every token - [20 Real-World Development Scenarios](https://developertoolkit.ai/en/cursor-ide/lessons/): Battle-tested Cursor workflows for the problems you actually face at work -- from greenfield projects to production fires. - [Building API Integrations with Cursor Agent](https://developertoolkit.ai/en/cursor-ide/lessons/api-integration/): Wire up third-party APIs with retry logic, circuit breakers, and proper error handling using Cursor's Agent mode and MCP servers. - [System Design with Cursor Agent](https://developertoolkit.ai/en/cursor-ide/lessons/architecture/): Use Cursor's Plan mode, Ask mode, and project rules to design scalable system architectures, evaluate trade-offs, and generate implementation plans before writing code. - [AI-Assisted Debugging in Cursor](https://developertoolkit.ai/en/cursor-ide/lessons/bug-hunting/): Track down intermittent failures, race conditions, and Heisenbugs using Cursor's Debug mode, Agent mode, and systematic investigation workflows. - [Setting Up CI/CD Using Cursor Agent](https://developertoolkit.ai/en/cursor-ide/lessons/ci-cd/): Build production-grade CI/CD pipelines with GitHub Actions using Cursor Agent to generate workflows, fix failing builds, and automate deployments. - [AI-Enhanced Code Reviews in Cursor](https://developertoolkit.ai/en/cursor-ide/lessons/code-review/): Use Cursor's Agent Review, BugBot, and CLI-powered workflows to catch bugs, enforce standards, and speed up code reviews without sacrificing quality. - [Data Processing Pipeline with Cursor](https://developertoolkit.ai/en/cursor-ide/lessons/data-pipeline/): Design and build ETL pipelines, data transformations, and batch processing systems using Cursor Agent for schema design, transformation logic, and error handling. - [Database Schema Design Using Cursor](https://developertoolkit.ai/en/cursor-ide/lessons/database-design/): Design normalized schemas, write migrations, catch performance traps, and iterate on your data model using Cursor's Ask and Agent modes. - [Infrastructure as Code Using Cursor](https://developertoolkit.ai/en/cursor-ide/lessons/devops/): Generate, validate, and manage Terraform, Docker, and Kubernetes configurations using Cursor Agent with infrastructure-aware project rules and deployment workflows. - [Auto-Generating Docs with Cursor Agent](https://developertoolkit.ai/en/cursor-ide/lessons/documentation/): Generate API references, architecture diagrams, onboarding guides, and living documentation from your codebase using Cursor's Agent and Ask modes. - [UI Implementation from Designs with Cursor](https://developertoolkit.ai/en/cursor-ide/lessons/frontend-ui/): Turn Figma mockups and screenshots into production React components using Cursor's Agent mode, image context, and inline edits. - [Refactoring Legacy Code with Cursor](https://developertoolkit.ai/en/cursor-ide/lessons/legacy-refactor/): Modernize an untested, callback-heavy codebase safely using Cursor's inline edits, Agent mode, and checkpoint system. - [Microservices Development in Cursor](https://developertoolkit.ai/en/cursor-ide/lessons/microservices/): Design, scaffold, and manage microservices architectures using Cursor Agent's multi-file editing, multi-root workspaces, and service-aware context. - [Framework Migration Workflow in Cursor](https://developertoolkit.ai/en/cursor-ide/lessons/migration/): Plan and execute large-scale migrations between frameworks, libraries, and API versions using Cursor Agent's multi-file editing, Plan mode, and incremental transformation strategies. - [Mobile App Development with Cursor](https://developertoolkit.ai/en/cursor-ide/lessons/mobile-dev/): Build, debug, and iterate on React Native and cross-platform mobile apps using Cursor Agent with platform-specific rules, device previewing, and native module workflows. - [Logging and Monitoring Setup in Cursor](https://developertoolkit.ai/en/cursor-ide/lessons/monitoring/): Build structured logging, application metrics, distributed tracing, and alerting systems using Cursor Agent to generate observability infrastructure from scratch. - [Starting a New Project Using Cursor Agent](https://developertoolkit.ai/en/cursor-ide/lessons/new-project/): Go from a vague PM spec to a running full-stack application in hours using Cursor's Agent mode, Plan mode, and project rules. - [Using Cursor as AI Pair Programmer](https://developertoolkit.ai/en/cursor-ide/lessons/pair-programming/): Move beyond one-shot prompts to a continuous, conversational coding workflow where Cursor Agent acts as a thinking partner through design, implementation, and debugging. - [Performance Optimization Using Cursor](https://developertoolkit.ai/en/cursor-ide/lessons/performance/): Profile, identify bottlenecks, and fix N+1 queries, bundle bloat, and rendering jank using Cursor's Agent and Ask modes. - [Security Audit Workflow in Cursor](https://developertoolkit.ai/en/cursor-ide/lessons/security/): Run a systematic security review of your codebase using Cursor's Agent and Ask modes to find and fix vulnerabilities before they reach production. - [Test-Driven Development in Cursor](https://developertoolkit.ai/en/cursor-ide/lessons/testing-tdd/): Use Cursor's Agent mode to write tests first, then implement until they pass -- the TDD loop accelerated by AI. - [Cursor Productivity Patterns](https://developertoolkit.ai/en/cursor-ide/productivity-patterns/): Workflow optimization patterns that compound into significant time savings with Cursor - [Context Patterns](https://developertoolkit.ai/en/cursor-ide/productivity-patterns/context-patterns/): Strategies for giving Cursor exactly the right context for better AI output with less waste - [Debugging Workflows in Cursor](https://developertoolkit.ai/en/cursor-ide/productivity-patterns/debugging-workflows/): Systematic debugging approaches in Cursor that find root causes faster than trial-and-error - [Keyboard Shortcuts Mastery](https://developertoolkit.ai/en/cursor-ide/productivity-patterns/keyboard-shortcuts/): The Cursor keyboard shortcuts that actually matter, organized by workflow instead of alphabetically - [Prompt Templates](https://developertoolkit.ai/en/cursor-ide/productivity-patterns/prompt-templates/): A reusable library of Cursor prompts for feature implementation, debugging, refactoring, and more - [Refactoring Strategies](https://developertoolkit.ai/en/cursor-ide/productivity-patterns/refactoring-strategies/): Large-scale refactoring patterns with Cursor that are safe, incremental, and verifiable - [Review Workflows](https://developertoolkit.ai/en/cursor-ide/productivity-patterns/review-workflows/): Code review patterns in Cursor that catch more bugs, provide better feedback, and prevent the review bottleneck - [Snippet Management](https://developertoolkit.ai/en/cursor-ide/productivity-patterns/snippet-management/): Code snippet workflows that integrate with Cursor AI for rapid, pattern-consistent development without boilerplate drift. - [Testing Patterns](https://developertoolkit.ai/en/cursor-ide/productivity-patterns/testing-patterns/): AI-powered test generation, test-driven development, and test maintenance workflows in Cursor - [Time Savers](https://developertoolkit.ai/en/cursor-ide/productivity-patterns/time-savers/): Daily workflow optimizations in Cursor that eliminate repetitive tasks and compound into hours saved per week - [Cursor Quick Start: Your 2-Hour Setup Guide](https://developertoolkit.ai/en/cursor-ide/quick-start/): Go from zero to productive with Cursor in a single focused session -- installation, configuration, rules, MCP, and your first AI-built feature. - [Version Control and Team Collaboration](https://developertoolkit.ai/en/cursor-ide/quick-start/collaboration/): Use Cursor for AI-assisted commits, merge-conflict resolution, BugBot PR reviews, shared rules, and Cloud Agents launched from Slack. - [Context Management](https://developertoolkit.ai/en/cursor-ide/quick-start/context-management/): Master @ symbols, file references, docs integration, and past chats -- the context skills that determine whether the AI helps or hallucinates. - [Debugging and Error Recovery](https://developertoolkit.ai/en/cursor-ide/quick-start/error-handling/): Patterns for debugging AI-generated code, recovering from broken builds, using checkpoints, and handling the inevitable moments when the agent goes off the rails. - [Essential Configuration](https://developertoolkit.ai/en/cursor-ide/quick-start/essential-configuration/): Configure auto-run mode, Max mode, and privacy settings -- the three settings that separate productive Cursor users from frustrated ones. - [Build Your First AI-Assisted Feature](https://developertoolkit.ai/en/cursor-ide/quick-start/first-feature/): Put everything together -- rules, context, Plan mode, and Agent mode -- to build a real feature end-to-end with Cursor. - [Installation and Platform Setup](https://developertoolkit.ai/en/cursor-ide/quick-start/installation-setup/): Get Cursor installed on macOS, Windows, or Linux in under 10 minutes -- including VS Code migration, shell commands, and verifying your setup. - [MCP Setup in Cursor](https://developertoolkit.ai/en/cursor-ide/quick-start/mcp-setup/): Configure Model Context Protocol servers to connect Cursor's agent to databases, browsers, GitHub, and external APIs -- with real configuration examples. - [Model Selection Strategy](https://developertoolkit.ai/en/cursor-ide/quick-start/model-selection/): A practical decision framework for choosing between Claude Opus 5, Grok 4.5, GPT-5.6, Gemini, and Composer 2.5 in Cursor -- based on task type, budget, and context needs. - [PRD Workflow in Cursor](https://developertoolkit.ai/en/cursor-ide/quick-start/prd-workflow/): Use Cursor's Plan mode to turn product requirements into implementation plans and trackable todo lists -- the methodology that makes complex features manageable. - [Project Rules](https://developertoolkit.ai/en/cursor-ide/quick-start/project-rules/): Set up .cursor/rules/ with persistent instructions that teach the AI your codebase conventions, architecture patterns, and team standards. - [AI-Powered Testing and Quality Assurance](https://developertoolkit.ai/en/cursor-ide/quick-start/testing-quality/): Master test-driven development, automated testing, and quality assurance with Cursor's AI capabilities - [112 Cursor Tips That Actually Change How You Work](https://developertoolkit.ai/en/cursor-ide/tips-tricks/): The complete collection of battle-tested Cursor tips organized by workflow. Numbered, actionable, with copy-paste prompts you can use today. - [Advanced Techniques: Tips 91-105](https://developertoolkit.ai/en/cursor-ide/tips-tricks/advanced-techniques/): MCP servers, background agents, custom automations, Bugbot reviews, and the expert-level workflows that turn Cursor from a coding tool into a development platform. - [Agent and Chat Optimization: Tips 61-75](https://developertoolkit.ai/en/cursor-ide/tips-tricks/agent-chat/): Multi-file features, test-driven agent prompts, context management, and the autonomous workflows that let Cursor implement while you architect. - [Core Features: Tips 16-30](https://developertoolkit.ai/en/cursor-ide/tips-tricks/core-features/): Essential shortcuts, navigation patterns, and daily-driver features that separate Cursor beginners from productive users. - [Inline Edit Strategies: Tips 46-60](https://developertoolkit.ai/en/cursor-ide/tips-tricks/inline-edit/): Transform code with Cmd+K using natural language instructions. Selection strategies, chained edits, and the prompts that turn inline edit into a surgical refactoring tool. - [Large Codebase Strategies: Tips 76-90](https://developertoolkit.ai/en/cursor-ide/tips-tricks/large-codebase/): Monorepos, indexing strategy, context budgets, and multi-root workspaces. How to keep Cursor fast and accurate when your project has hundreds of thousands of lines. - [Cursor Setup & Configuration](https://developertoolkit.ai/en/cursor-ide/tips-tricks/setup-configuration/): Installation, Auto-Run, model selection, project rules, and indexing optimizations that turn Cursor from a fancy editor into an autonomous development partner. - [Tab Autocomplete Mastery: Tips 31-45](https://developertoolkit.ai/en/cursor-ide/tips-tricks/tab-autocomplete/): Make Cursor's Tab predictions type half your code: multi-line completions, partial accepts, pattern training, and the mental model that makes Tab feel like mind reading. - [Team Collaboration: Tips 106-112](https://developertoolkit.ai/en/cursor-ide/tips-tricks/team-collaboration/): Shared rules, team onboarding, AI-assisted code review, and the configuration management that makes an entire team productive with Cursor -- not just individuals. - [Staying Current with Cursor](https://developertoolkit.ai/en/cursor-ide/version-management/): Master version management, update strategies, and feature adoption to maximize your Cursor experience - [Version History & Features](https://developertoolkit.ai/en/cursor-ide/version-management/changelog/): Complete changelog documenting Cursor's evolution from early versions through the latest releases - [Feature Adoption Strategies](https://developertoolkit.ai/en/cursor-ide/version-management/feature-adoption/): Learn how to discover, evaluate, and adopt new Cursor features effectively while managing risk and maximizing productivity gains - [Cursor Upgrade Guides](https://developertoolkit.ai/en/cursor-ide/version-management/upgrade-guides/): Upgrade Cursor safely with a pre-flight checklist, three-channel strategy, and four rollback methods when an update breaks your extensions or MCP servers mid-sprint. ## OpenAI Codex - [ChatGPT Codex](https://developertoolkit.ai/en/codex/): Master ChatGPT Codex across the ChatGPT desktop app, CLI, IDE, mobile, and Cloud with the GPT-5.6 Sol, Terra, and Luna family. - [Advanced Codex Techniques](https://developertoolkit.ai/en/codex/advanced-techniques/): Expert-level ChatGPT Codex techniques across desktop, CLI, Cloud, and IDE surfaces - [ChatGPT Desktop Codex Mastery](https://developertoolkit.ai/en/codex/advanced-techniques/app-mastery/): Multi-project orchestration, parallel threads, IDE sync, and advanced Codex workflows in ChatGPT desktop - [Scheduled Recurring Automations](https://developertoolkit.ai/en/codex/advanced-techniques/automations/): Set up scheduled Codex tasks in ChatGPT desktop and understand the separate web scheduling path - [Cloud Execution Environments](https://developertoolkit.ai/en/codex/advanced-techniques/cloud-environments/): Configure Codex cloud environments, container caching, internet access policies, and best-of-N parallel attempts - [Building with the Codex SDK](https://developertoolkit.ai/en/codex/advanced-techniques/codex-sdk/): Use the @openai/codex-sdk TypeScript library to programmatically control Codex threads for custom tooling and integrations - [Credits, Usage Limits, and Cost Optimization](https://developertoolkit.ai/en/codex/advanced-techniques/cost-management/): Understand Codex pricing tiers, credit systems, and proven strategies to maximize value from your Codex subscription - [Enterprise Governance and Compliance](https://developertoolkit.ai/en/codex/advanced-techniques/enterprise-governance/): Enterprise admin setup, RBAC, governance APIs, audit logging, and security controls for Codex at scale - [Codex GitHub Action](https://developertoolkit.ai/en/codex/advanced-techniques/github-action/): Automate PR reviews, quality checks, and CI/CD tasks with the official openai/codex-action for GitHub Actions - [Headless and Non-Interactive Mode](https://developertoolkit.ai/en/codex/advanced-techniques/non-interactive/): Use codex exec for scripted automation, CI/CD pipelines, structured JSON output, and machine-readable results - [Slack and Linear Workflow Integration](https://developertoolkit.ai/en/codex/advanced-techniques/slack-linear-integration/): Delegate coding tasks from Slack channels and Linear issues directly to Codex cloud agents - [Git Worktree Parallel Development](https://developertoolkit.ai/en/codex/advanced-techniques/worktrees/): Run multiple Codex agents in parallel using Git worktrees in the ChatGPT desktop app in Codex mode, each on an isolated checkout so their changes never collide - [20 Real-World Codex Scenarios](https://developertoolkit.ai/en/codex/lessons/): Master ChatGPT Codex through battle-tested workflows that ship production code with parallel agents, worktrees, and automations - [API Development with Codex](https://developertoolkit.ai/en/codex/lessons/api-development/): Build production-ready REST and GraphQL APIs using Codex's multi-surface workflow for scaffolding, testing, and documentation in parallel - [System Design with Codex](https://developertoolkit.ai/en/codex/lessons/architecture/): Use Codex for architectural decisions by planning in the IDE, validating with cloud tasks, and iterating across surfaces until the design is right - [Scheduled Task Automation with Codex](https://developertoolkit.ai/en/codex/lessons/automation/): Set up recurring automations for daily code reviews, weekly dependency updates, nightly bug hunts, and custom skills that run on schedule - [Debugging with Codex Across Surfaces](https://developertoolkit.ai/en/codex/lessons/bug-hunting/): Hunt bugs across the ChatGPT desktop app in Codex mode, CLI, IDE extension, GitHub, and cloud with reproduction-first debugging workflows - [CI/CD with Codex GitHub Action](https://developertoolkit.ai/en/codex/lessons/ci-cd/): Run Codex in GitHub Actions for automated code review, quality gates, and release preparation using the official codex-action - [AI-Powered Code Review with /review](https://developertoolkit.ai/en/codex/lessons/code-review/): Use Codex's built-in review system across the CLI, App, and GitHub for consistent, thorough code review on every change - [Understanding Codebases with Codex](https://developertoolkit.ai/en/codex/lessons/codebase-analysis/): Onboard to unfamiliar repositories using Codex across the App, CLI, IDE extension, and cloud for fast architectural understanding - [Legacy Code Modernization at Scale](https://developertoolkit.ai/en/codex/lessons/codebase-modernization/): Modernize entire codebases using Codex cloud tasks with multiple attempts, parallel worktrees, and systematic migration patterns - [Database Operations with Codex](https://developertoolkit.ai/en/codex/lessons/database-work/): Design schemas, generate migrations, optimize queries, and seed test data using Codex across local and cloud environments - [Deployment Automation with Codex](https://developertoolkit.ai/en/codex/lessons/deployment/): Automate deployment workflows from Dockerfiles to production using Codex cloud tasks, the GitHub Action, and scheduled automations - [Documentation Generation with Codex](https://developertoolkit.ai/en/codex/lessons/documentation/): Generate API docs, architecture guides, and changelogs from your codebase with Codex, then automate updates on a schedule - [Building Features with Parallel Agents](https://developertoolkit.ai/en/codex/lessons/feature-development/): Develop features faster by running multiple Codex agents in isolated worktrees, planning locally and executing in parallel - [Slack and Linear Integration Workflows](https://developertoolkit.ai/en/codex/lessons/integrations/): Delegate coding tasks from Slack channels and Linear issues to Codex cloud agents, and get PRs back where your team already works - [Starting Projects with ChatGPT Desktop (Codex Mode)](https://developertoolkit.ai/en/codex/lessons/new-project/): Bootstrap production-ready projects from the ChatGPT desktop app in Codex mode with AGENTS.md, local environments, and your first worktree thread - [Multi-Agent Parallel Feature Work](https://developertoolkit.ai/en/codex/lessons/parallel-development/): Run multiple Codex agents simultaneously in separate worktrees to ship entire feature sets in hours instead of days - [Performance Optimization with Codex](https://developertoolkit.ai/en/codex/lessons/performance/): Profile bottlenecks, optimize queries, and benchmark changes using Codex cloud tasks with best-of-N attempts for exploring optimization strategies - [Pull Request Automation Workflow](https://developertoolkit.ai/en/codex/lessons/pr-automation/): Automate the PR lifecycle from creation through review to merge using @codex on GitHub, the ChatGPT desktop app in Codex mode, and the GitHub Action - [Large-Scale Refactoring with Worktrees](https://developertoolkit.ai/en/codex/lessons/refactoring/): Refactor across hundreds of files using Codex worktrees for isolation, parallel execution, and safe incremental merging - [Security Scanning with Codex](https://developertoolkit.ai/en/codex/lessons/security-audit/): Scan for vulnerabilities, audit dependencies, and automate security checks using Codex across local, cloud, and GitHub surfaces - [Test Generation and Execution with Codex](https://developertoolkit.ai/en/codex/lessons/testing/): Generate comprehensive test suites in isolated worktrees, run them without touching your working directory, and automate coverage checks - [Codex Productivity Patterns](https://developertoolkit.ai/en/codex/productivity-patterns/): Workflow optimization patterns for maximizing development throughput across all Codex surfaces - [Bulk Changes with Cloud and Worktrees](https://developertoolkit.ai/en/codex/productivity-patterns/batch-operations/): Apply consistent changes across dozens of files, packages, or repositories using parallel Codex agents - [Context Management Across Codex Surfaces](https://developertoolkit.ai/en/codex/productivity-patterns/context-patterns/): Keep Codex focused and efficient by managing context windows, compaction, AGENTS.md hierarchy, and cross-surface context flow - [Systematic Debugging Across Surfaces](https://developertoolkit.ai/en/codex/productivity-patterns/debugging-workflows/): Debug production issues, test failures, and complex bugs using Codex across App, CLI, Cloud, and IDE surfaces - [Daily Productivity Boosters for Codex](https://developertoolkit.ai/en/codex/productivity-patterns/efficiency-hacks/): Quick techniques, keyboard shortcuts, and workflow optimizations that save minutes on every Codex session - [Orchestrating Multiple Parallel Agents](https://developertoolkit.ai/en/codex/productivity-patterns/multi-agent-workflows/): Run multiple Codex agents simultaneously across worktrees, cloud, and local threads for maximum development throughput - [Effective Prompting and AGENTS.md Strategies](https://developertoolkit.ai/en/codex/productivity-patterns/prompt-engineering/): Write prompts and project-level instructions that consistently produce high-quality Codex results across all surfaces - [Efficient Agent Work Review and Approval](https://developertoolkit.ai/en/codex/productivity-patterns/review-strategies/): Systematic strategies for reviewing Codex-generated code, diffs, and PRs without becoming the bottleneck - [Team Collaboration and Shared Configuration](https://developertoolkit.ai/en/codex/productivity-patterns/team-workflows/): Standardize Codex usage across your team with shared configs, skills, AGENTS.md conventions, and collaborative workflows - [Getting Started with Codex](https://developertoolkit.ai/en/codex/quick-start/): Go from zero to shipping code with ChatGPT Codex across desktop, CLI, IDE, and Cloud - [AGENTS.md Setup](https://developertoolkit.ai/en/codex/quick-start/agents-md/): Write global and project-level AGENTS.md files that give Codex real context about your codebase conventions - [Authentication](https://developertoolkit.ai/en/codex/quick-start/authentication/): Configure ChatGPT login or OpenAI API key access for local Codex clients and understand cloud requirements - [Configuration](https://developertoolkit.ai/en/codex/quick-start/configuration/): Configure config.toml for models, approval modes, sandbox levels, and feature flags across all Codex surfaces - [Error Recovery](https://developertoolkit.ai/en/codex/quick-start/error-recovery/): Handle Codex failures, sandbox errors, wrong-direction edits, and command timeouts across all surfaces - [Your First Codex Task](https://developertoolkit.ai/en/codex/quick-start/first-task/): Run a real coding task across all four Codex surfaces and see how each handles the same prompt differently - [GitHub Integration](https://developertoolkit.ai/en/codex/quick-start/github-integration/): Connect Codex to GitHub for PR workflows, automatic code reviews, and @codex mentions in issues - [Installation](https://developertoolkit.ai/en/codex/quick-start/installation/): Install ChatGPT Codex in the desktop app, CLI, and IDE extension across macOS, Linux, and Windows - [MCP Setup](https://developertoolkit.ai/en/codex/quick-start/mcp-setup/): Connect Codex to third-party tools and documentation using Model Context Protocol servers - [Review Workflow](https://developertoolkit.ai/en/codex/quick-start/review-workflow/): Review, refine, and merge Codex's changes using the App's review pane, inline comments, and Git staging - [Essential Codex Tips and Tricks](https://developertoolkit.ai/en/codex/tips-tricks/): A curated collection of practical tips across installation, configuration, App features, CLI commands, cloud workflows, AGENTS.md, and team collaboration - [Advanced Codex Tips](https://developertoolkit.ai/en/codex/tips-tricks/advanced-techniques/): Power user techniques for multi-surface orchestration, custom model providers, SDK integration, observability, and non-obvious Codex capabilities - [AGENTS.md and Skills Mastery](https://developertoolkit.ai/en/codex/tips-tricks/agents-md-optimization/): Optimize AGENTS.md hierarchy, write effective skills, manage context budgets, and keep Codex aligned with your project conventions - [ChatGPT Desktop Codex Tips](https://developertoolkit.ai/en/codex/tips-tricks/app-features/): Get the most out of Codex mode in ChatGPT desktop with worktrees, automations, IDE sync, and visual diff review - [CLI and Slash Command Tips](https://developertoolkit.ai/en/codex/tips-tricks/cli-commands/): Master the Codex CLI with session management, image inputs, scripting patterns, slash commands, and non-obvious keyboard shortcuts - [Cloud Environment Tips](https://developertoolkit.ai/en/codex/tips-tricks/cloud-workflows/): Get the most out of Codex Cloud with environment setup, container caching, internet access policies, best-of-N strategies, and cost-effective task submission - [Installation and Configuration Tips](https://developertoolkit.ai/en/codex/tips-tricks/setup-configuration/): Get Codex set up correctly across App, CLI, and IDE Extension with config.toml recipes, authentication shortcuts, and environment preparation tips - [Team and Enterprise Tips](https://developertoolkit.ai/en/codex/tips-tricks/team-collaboration/): Standardize Codex across your team with shared configs, Team Config deployment, onboarding patterns, governance controls, and cost management strategies - [Staying Current with Codex](https://developertoolkit.ai/en/codex/version-management/): Master Codex version management and updates across CLI, app, and IDE, and stay informed about new features. - [Codex Version History](https://developertoolkit.ai/en/codex/version-management/changelog/): Complete changelog documenting Codex CLI, desktop app, and IDE extension releases, with version numbers, dates, and feature highlights for each release. ## Shared Workflows - [Shared Workflows](https://developertoolkit.ai/en/shared-workflows/): Cross-tool workflows and techniques that work across Cursor, Claude Code, and Codex. Learn tool-agnostic patterns for AI-assisted development. - [Best Practices for AI-Assisted Development](https://developertoolkit.ai/en/shared-workflows/best-practices/): Go beyond good prompting. Learn the context, Plan-Execute-Verify workflow, and review discipline that separate expert AI-powered developers from novices — across Cursor, Claude Code, and Codex. - [Choosing the Right Mode: Agent vs. Ask](https://developertoolkit.ai/en/shared-workflows/best-practices/agent-vs-ask-mode/): Use read-only Ask/plan mode to explore and plan, then switch to Agent/execution mode to implement — across Cursor, Claude Code, and Codex. The discipline that stops AI editing the wrong files. - [The Human in the Loop: The Developer's Evolving Role](https://developertoolkit.ai/en/shared-workflows/best-practices/human-in-the-loop/): AI assistants are collaborators, not replacements. See how the developer's role shifts from typist to architect, supervisor, and reviewer — and the prompts and review gates that keep you in the loop. - [Managing Large Codebases](https://developertoolkit.ai/en/shared-workflows/best-practices/managing-large-codebases/): Keep AI assistants accurate in 500k-LOC monorepos: context discovery, codebase indexing, and task decomposition across Cursor, Claude Code, and Codex. - [Privacy and Security Best Practices](https://developertoolkit.ai/en/shared-workflows/best-practices/privacy-security/): Use AI assistants on proprietary code without leaking it: per-tool privacy settings, secret-scanning prompts, and least-privilege MCP server config. - [Effective Prompting Techniques](https://developertoolkit.ai/en/shared-workflows/best-practices/prompting-techniques/): Guide an AI assistant's reasoning to ship better code: clarification-first prompts, plan-then-execute, few-shot patterns, and a per-tool troubleshooting playbook. - [Team Collaboration: Shared Context and Rules](https://developertoolkit.ai/en/shared-workflows/best-practices/team-collaboration/): Stop relitigating coding standards in every code review. Use version-controlled rule files to make Cursor, Claude Code, and Codex enforce your team's conventions for everyone, automatically. - [Context Management](https://developertoolkit.ai/en/shared-workflows/context-management/): Context is the single most important resource in AI-assisted development. Provide the right information at the right time to get reliable, production-quality output from your coding agent. - [Search and Indexing Strategies](https://developertoolkit.ai/en/shared-workflows/context-management/codebase-indexing/): How semantic search, grep, and file-based navigation work across Cursor, Claude Code, and Codex - and how to optimize your project for fast, accurate code discovery. - [Understanding Context Windows and Token Limits](https://developertoolkit.ai/en/shared-workflows/context-management/context-windows/): Context windows are the fundamental constraint of AI-assisted development. Learn how tokens work, what happens when you exceed limits, and practical strategies for staying within bounds. - [Context Cost Optimization](https://developertoolkit.ai/en/shared-workflows/context-management/cost-per-context/): Every token costs money. Learn the cost structure of AI coding assistants, how context usage becomes real dollars, and practical strategies for great results while keeping your bill under control. - [Using Documentation as Effective AI Context](https://developertoolkit.ai/en/shared-workflows/context-management/documentation-as-context/): Your CLAUDE.md, .cursor/rules, and AGENTS.md files are the highest-leverage context you can give an AI. Learn how to write docs that make your assistant dramatically more effective from prompt one. - [Project Structure Optimized for AI](https://developertoolkit.ai/en/shared-workflows/context-management/file-organization/): How you organize your project affects how well AI coding assistants understand and navigate your code. Learn file organization patterns that reduce context waste and improve AI output quality. - [Long-Term Context Retention Patterns](https://developertoolkit.ai/en/shared-workflows/context-management/memory-patterns/): AI assistants forget everything between sessions. Use auto-memory, project rules, and instruction files to build persistent knowledge that survives context resets and speeds up every session. - [Pruning CLAUDE.md and AGENTS.md: The Ablation Protocol](https://developertoolkit.ai/en/shared-workflows/context-management/pruning-context-files/): Context-file advice inverted in July 2026: stop adding a rule per mistake, start deleting. A dated map of why, what each tool actually loads and when, and nine prompts that do the cutting. - [Core Development Methodologies](https://developertoolkit.ai/en/shared-workflows/core-methodology/): Battle-tested methodologies for AI-assisted development that ship stable, production-ready code -- not just prototypes. - [When to Use Agent vs Ask Mode](https://developertoolkit.ai/en/shared-workflows/core-methodology/agent-vs-ask-mode/): Every AI coding tool offers modes ranging from autonomous execution to read-only analysis. Choosing the right mode for the right task is the difference between productive sessions and wasted context. - [Continuous Delivery with AI Assistance](https://developertoolkit.ai/en/shared-workflows/core-methodology/continuous-delivery/): Ship small, verified changes continuously. AI accelerates every step of the delivery pipeline when you pair it with automated verification, incremental commits, and disciplined release practices. - [Error-Driven Development](https://developertoolkit.ai/en/shared-workflows/core-methodology/error-driven-development/): Stop fighting errors and start using them as your primary feedback signal. Turn compiler errors, test failures, and runtime exceptions into precise AI prompts that converge on correct code. - [Effective Human-AI Collaboration Patterns](https://developertoolkit.ai/en/shared-workflows/core-methodology/human-in-the-loop/): Know when to intervene, when to let the AI run, and how to review AI-generated code without becoming a bottleneck. The patterns that keep you in control while maximizing AI throughput. - [The PRD to Plan to Todo Methodology](https://developertoolkit.ai/en/shared-workflows/core-methodology/prd-plan-todo/): Transform vague requirements into precise, executable task lists that AI coding assistants can implement reliably. The foundational workflow for shipping features, not prototypes. - [Test-Driven Development with AI Assistance](https://developertoolkit.ai/en/shared-workflows/core-methodology/test-driven-development/): Write tests first, then let AI write the implementation. TDD gives your AI assistant an unambiguous definition of 'done' and a built-in verification loop that catches mistakes before you do. - [DevOps with AI](https://developertoolkit.ai/en/shared-workflows/deployment-operations/): Ship deploys, infrastructure, and incident response faster with AI assistance across Cursor, Claude Code, and Codex — the workflows, MCP servers, and gotchas. - [Pipeline Automation with AI](https://developertoolkit.ai/en/shared-workflows/deployment-operations/ci-cd-pipelines/): Build self-optimizing CI/CD pipelines with Cursor, Claude Code, and Codex — change-aware builds, flaky-test triage, and safe progressive deploys. - [Regulatory Compliance Automation](https://developertoolkit.ai/en/shared-workflows/deployment-operations/compliance-automation/): Using AI tools to automate compliance checks, generate audit trails, enforce security policies, and maintain SOC 2/HIPAA/GDPR compliance across your development lifecycle. - [Docker and Kubernetes Containerization](https://developertoolkit.ai/en/shared-workflows/deployment-operations/containerization/): Use Cursor, Claude Code, and Codex to generate hardened multi-stage Dockerfiles, debug OOMKilled pods, and wire up the Docker and Kubernetes MCP servers safely. - [Cloud Cost Management & FinOps](https://developertoolkit.ai/en/shared-workflows/deployment-operations/cost-optimization/): Cut cloud waste with AI-driven FinOps across Cursor, Claude Code, and Codex — right-sizing, anomaly detection, cost allocation, and budget forecasting with real MCP servers. - [AI-Powered Incident Response](https://developertoolkit.ai/en/shared-workflows/deployment-operations/incident-response/): Wire Cursor, Claude Code, and Codex into your observability stack with MCP servers to correlate alerts, run safe remediation, and generate post-mortems. - [Infrastructure as Code with AI Assistants](https://developertoolkit.ai/en/shared-workflows/deployment-operations/infrastructure-code/): Drive Terraform, CloudFormation, Pulumi, and CDK from natural language with Cursor, Claude Code, and Codex—plus the MCP servers that ground AI in real provider data. - [Monitoring and Observability](https://developertoolkit.ai/en/shared-workflows/deployment-operations/monitoring-observability/): Use Cursor, Claude Code, and Codex to instrument services with OpenTelemetry, build Grafana dashboards, write alert rules, and debug incidents with the Sentry MCP. - [Production Performance Optimization](https://developertoolkit.ai/en/shared-workflows/deployment-operations/performance-tuning/): Diagnose production bottlenecks and tune them with AI workflows across Cursor, Claude Code, and Codex — wired to Kubernetes and observability MCP servers. - [Security Operations Automation](https://developertoolkit.ai/en/shared-workflows/deployment-operations/security-operations/): Automate SecOps with AI: real scanner CLIs in CI, the AWS Security and Azure MCP servers, vulnerability triage, and compliance evidence across Cursor, Claude Code, and Codex. - [Design Pipeline](https://developertoolkit.ai/en/shared-workflows/design-pipeline/): An end-to-end design-to-code pipeline: GPT Image 2 mockups, GPT-5.6 Sol HTML prototypes with Pro reasoning, then Claude Design and coding agents. - [Four-Stage AI Design Pipeline](https://developertoolkit.ai/en/shared-workflows/design-pipeline/four-stage-pipeline/): Chain GPT Image 2, GPT-5.6 Sol in Pro mode, Claude Design, and Claude Code/Codex/Cursor into an end-to-end pipeline that turns a sketch into production-ready UI and documentation. - [Rating & Iteration Loop: Drive Every Artefact to 10/10](https://developertoolkit.ai/en/shared-workflows/design-pipeline/rating-loop/): A 0-10 self-critique loop you run at each handoff in the design pipeline so weak artefacts never propagate downstream. - [Standard Workflow Patterns](https://developertoolkit.ai/en/shared-workflows/development-workflows/): Repeatable AI development workflows that keep you in control. The core Plan, Execute, Verify patterns for Cursor, Claude Code, and Codex, with links to each deep dive. - [Agile Workflows: Scrum and Kanban Integration](https://developertoolkit.ai/en/shared-workflows/development-workflows/agile-workflows/): Wire AI coding agents into Scrum and Kanban: copy-paste prompts for sprint planning, review changelogs, and underspecified cards, plus board automation via the Linear and Atlassian MCP servers. - [Behavior-Driven Development Workflows](https://developertoolkit.ai/en/shared-workflows/development-workflows/behavior-driven-dev/): Drive AI-assisted development from Gherkin specs: turn acceptance criteria into Cucumber.js step definitions, implementation, and a green suite across Cursor, Claude Code, and Codex. - [Continuous Delivery Best Practices](https://developertoolkit.ai/en/shared-workflows/development-workflows/continuous-delivery/): Wire Cursor, Claude Code, and Codex into your CI/CD pipeline to review PRs, generate workflow YAML, gate deploys, and triage red builds with copy-paste prompts. - [Domain-Driven Design with AI Assistance](https://developertoolkit.ai/en/shared-workflows/development-workflows/domain-driven-design/): Use Cursor, Claude Code, and Codex as DDD partners: encode the ubiquitous language in context files, model aggregates, and enforce bounded-context rules with copy-paste prompts. - [Error-Driven Development: Learning from Failures](https://developertoolkit.ai/en/shared-workflows/development-workflows/error-driven-development/): Use compiler errors, failing tests, and stack traces as the feedback loop that drives Cursor, Claude Code, and Codex to a fix, with copy-paste prompts and an MCP shortcut. - [The /goal Command: Goal-Directed Autonomous Runs](https://developertoolkit.ai/en/shared-workflows/development-workflows/goal-command/): Hand your agent a finish line instead of a prompt. How /goal keeps Claude Code and Codex working turn after turn until a verifiable stopping condition is met -- and what to use in Cursor. - [herdr: The Agent Multiplexer With a Scriptable API](https://developertoolkit.ai/en/shared-workflows/development-workflows/herdr-agent-multiplexer/): Run your agent fleet in one terminal with real state detection, then use herdr's CLI and socket API to let one agent spawn and supervise all the others. - [The /loop Command: Recurring and Self-Paced Prompts](https://developertoolkit.ai/en/shared-workflows/development-workflows/loop-command/): Stop hand-polling deploys and PRs. How /loop runs a prompt on a schedule or a self-chosen interval in Claude Code and Cursor -- and why Codex covers the same need with /goal instead. - [The PRD→Plan→Todo Methodology](https://developertoolkit.ai/en/shared-workflows/development-workflows/prd-plan-todo-methodology/): Master the systematic approach to AI-assisted development. Learn how to transform product requirements into actionable tasks and high-quality code using the PRD→Plan→Todo workflow. - [The Core Methodology: PRD to Plan to Todo](https://developertoolkit.ai/en/shared-workflows/development-workflows/prd-plan-todo/): The quick-start workflow for AI-assisted development: turn a PRD into a technical plan and a step-by-step todo list, with plan-mode tips for Cursor, Claude Code, and Codex. - [Software Factories: How to Build One and Keep It From Rotting](https://developertoolkit.ai/en/shared-workflows/development-workflows/software-factories/): Agents write code faster than anyone can review it. What a software factory is, why Dex Horthy and PostHog are both right, and how to meter autonomy loop by loop instead of declaring it. - [Test-Driven Development with AI](https://developertoolkit.ai/en/shared-workflows/development-workflows/test-driven-development/): Partner with an AI assistant on TDD: write tests, confirm failure, then implement to pass. A reliable red-green-refactor loop across Cursor, Claude Code, and Codex. - [tmux for Agent Fleets: Sessions, send-keys, wait-for](https://developertoolkit.ai/en/shared-workflows/development-workflows/tmux-for-agent-fleets/): Your agent creates its own worktrees now. What tmux is still for: seeing which agent is blocked, surviving a closed laptop, passing work between six. - [Corporate Environment Guide](https://developertoolkit.ai/en/shared-workflows/enterprise-development/): Wire AI coding tools into enterprise SSO, MCP servers, audit trails, and corporate proxies across Cursor, Claude Code, and Codex without tripping security. - [API Development with AI](https://developertoolkit.ai/en/shared-workflows/enterprise-development/api-development/): Design and ship REST, GraphQL, and gRPC APIs with AI: spec-first schemas, validated endpoints, auth, contract and load tests, and versioning across Cursor, Claude Code, and Codex. - [AI-Powered Code Quality Gates](https://developertoolkit.ai/en/shared-workflows/enterprise-development/code-quality/): Implement comprehensive quality assurance with AI-driven code standards, automated reviews, and continuous quality monitoring across Cursor, Claude Code, and Codex - [AI Usage Cost Governance](https://developertoolkit.ai/en/shared-workflows/enterprise-development/cost-governance/): AI cost governance for engineering teams - monitor and control Cursor, Claude Code, and Codex spend with real telemetry, budgets, and model policy. - [Database Design and Queries](https://developertoolkit.ai/en/shared-workflows/enterprise-development/database-development/): AI-powered database development from schema design to query optimization using database MCP servers across Cursor, Claude Code, and Codex. - [AI-Powered Disaster Recovery](https://developertoolkit.ai/en/shared-workflows/enterprise-development/disaster-recovery/): Use Cursor, Claude Code, and Codex to author Postgres PITR runbooks, Chaos Mesh failover drills, and blameless post-mortems for real disaster recovery. - [Enterprise Security & Compliance Workflows](https://developertoolkit.ai/en/shared-workflows/enterprise-development/enterprise-security-compliance/): Lock down Cursor, Claude Code, and Codex for enterprise: privacy mode, managed policies, sandboxing, secret scanning, audit logs, and SOC2/GDPR/HIPAA guardrails. - [Million+ LOC Strategies](https://developertoolkit.ai/en/shared-workflows/enterprise-development/large-codebases/): Mastering AI-powered development in enterprise-scale codebases with millions of lines of code using Cursor, Claude Code, and Codex. - [Distributed Systems Development with AI](https://developertoolkit.ai/en/shared-workflows/enterprise-development/microservices/): Coordinate microservices changes, saga patterns, and observability across Cursor, Claude Code, and Codex—grounded in real MCP servers, not hallucinated install commands. - [Monorepo Workflows with AI Assistants](https://developertoolkit.ai/en/shared-workflows/enterprise-development/monorepo-management/): Master enterprise monorepo development with Cursor, Claude Code, and Codex using MCP servers for build orchestration, dependency graphs, and cross-package refactoring. - [Load Testing and Performance Analysis](https://developertoolkit.ai/en/shared-workflows/enterprise-development/performance-testing/): Use AI to generate k6 load tests, analyze bottlenecks, and catch Core Web Vitals regressions across Cursor, Claude Code, and Codex with the official k6 and Sentry MCP servers. - [Security Standards and Compliance](https://developertoolkit.ai/en/shared-workflows/enterprise-development/security-compliance/): Gate AI-assisted development for SOC 2, GDPR, and HIPAA — real audit logging, MCP supply-chain scanning, and CI policy enforcement across Cursor, Claude Code, and Codex. - [Enterprise AI Development Guide](https://developertoolkit.ai/en/shared-workflows/enterprise/): Strategic playbook for deploying AI coding tools across enterprise engineering organizations with governance, security, and measurable ROI. - [Quality Gates and Enforcement](https://developertoolkit.ai/en/shared-workflows/enterprise/code-quality/): Enforce consistent code quality standards across enterprise teams using AI-powered quality gates, automated reviews, and measurable quality metrics. - [AI Usage Cost Control and Budgeting](https://developertoolkit.ai/en/shared-workflows/enterprise/cost-governance/): Control and optimize AI tool spending across engineering teams with model routing, usage policies, budget tracking, and ROI measurement. - [Backup, Recovery, and Rollback](https://developertoolkit.ai/en/shared-workflows/enterprise/disaster-recovery/): Implement disaster recovery strategies for AI-assisted development including checkpoint management, rollback procedures, and recovery from AI-introduced regressions. - [Enterprise Large Codebase Strategies](https://developertoolkit.ai/en/shared-workflows/enterprise/large-codebases/): Navigate and modify codebases with over a million lines of code using AI tools without overwhelming context windows or losing architectural coherence. - [Distributed Systems with AI Assistance](https://developertoolkit.ai/en/shared-workflows/enterprise/microservices/): Coordinate AI-powered development across microservice boundaries with contract-first design, cross-service debugging, and distributed refactoring. - [Monorepo Workflows with AI](https://developertoolkit.ai/en/shared-workflows/enterprise/monorepo-management/): Manage monorepo architectures with AI-powered cross-package refactoring, dependency analysis, and coordinated releases. - [Data Privacy and Enterprise Policies](https://developertoolkit.ai/en/shared-workflows/enterprise/privacy-data-handling/): Implement data privacy policies for AI-assisted development including data classification, handling procedures, and compliance with privacy regulations. - [Enterprise Security Compliance](https://developertoolkit.ai/en/shared-workflows/enterprise/security-compliance/): Implement enterprise security standards and regulatory compliance with AI-assisted development while maintaining audit trails and data governance. - [Team Onboarding and Adoption Strategies](https://developertoolkit.ai/en/shared-workflows/enterprise/team-adoption/): Drive successful AI tool adoption across engineering teams with champion networks, training programs, and measurable adoption metrics. - [Introduction to Model Context Protocol](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/): MCP is the open standard that turns your AI assistant from a code generator into an integrated development partner. Learn what it is and how it works across Cursor, Claude Code, and Codex. - [Atlassian Rovo MCP Deep Dive](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/atlassian-mcp/): Connect your AI to Jira, Confluence, and Compass via the Atlassian Rovo MCP server: a single OAuth 2.1 remote endpoint for reading tickets, searching docs, and updating issues from your editor. - [Browser MCP: Playwright, Puppeteer & Chrome DevTools](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/browser-automation/): Give your AI eyes and hands in the browser. Set up Playwright, Puppeteer, and Chrome DevTools MCP servers for automated testing, UI verification, performance audits, and web scraping across Cursor, Claude Code, and Codex. - [Cloudflare MCP Servers](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/cloudflare-mcp/): Cloudflare offers 16 managed remote MCP servers covering Workers, KV, R2, D1, and more. Deploy, debug, and manage your edge infrastructure without leaving your editor. - [Building Your Own MCP Server](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/custom-mcp-development/): When no existing MCP server fits your workflow, build your own. This guide walks through creating a custom MCP server in TypeScript or Python, from hello-world to production deployment. - [Building Custom MCP Servers](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/custom-servers/): Connect your AI assistant to your own internal tools and APIs. Build a custom MCP server in TypeScript to give your AI deep, secure context on your organization's systems. - [Database Access: SQL & NoSQL](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/database-access/): Two workflows that pay off the moment your AI can read your database: generating a data model straight from a live table, and debugging production data without leaving your editor. - [SQL and NoSQL Database MCP Servers](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/database-mcp/): Stop guessing at schemas and hand-writing queries. Connect your AI to PostgreSQL, MongoDB, SQLite, and more through MCP servers that give it direct access to your data layer. - [Design-to-Code: Figma and Design Systems](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/design-to-code/): Go beyond one-off component generation. Use Figma MCP, design tokens, and Code Connect to make AI-generated UI reuse your real design system instead of inventing new colors and components. - [Figma and Design System MCP](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/design-tools-mcp/): Turn Figma frames into production components without leaving your editor. The Figma MCP server gives your AI direct access to design data, tokens, and component hierarchies. - [Context7 and Documentation MCP](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/documentation-context/): Your AI's training data is months old. Documentation MCP servers like Context7 give it real-time access to current library docs, eliminating deprecated API suggestions and outdated patterns. - [Must-Have MCP Servers for Every Developer](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/essential-servers/): Stop drowning in context-switching. Five MCP server categories anchor every serious AI workflow: version control, filesystem, documentation, browser automation, and project management. - [File Operations MCP](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/filesystem-mcp/): Give your AI structured, secure access to your filesystem. Configure the official Filesystem MCP server and Desktop Commander for safe file operations across Cursor, Claude Code, and Codex. - [MCP Best Practices: Optimization and Performance](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/mcp-best-practices/): You have MCP servers installed. Now make them fast, reliable, and context-efficient: context window management, server orchestration, caching, and inspection across all three tools. - [MCP Server Connection Issues](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/mcp-connection-issues/): Diagnose MCP server connection failures across Cursor, Claude Code, and Codex — red dots, spawn ENOENT, auth failures, timeouts, and the OS-level fixes that actually work. - [Securing and Hardening MCP Servers](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/mcp-security/): MCP servers run with your full local access. Learn to evaluate third-party servers, scope permissions, protect credentials, and defend against prompt injection before connecting anything to your AI. - [Microsoft and Azure MCP Servers](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/microsoft-azure-mcp/): Microsoft is embedding MCP across Azure and Visual Studio. Access Azure resources, GitHub Copilot, and Microsoft 365 data through MCP servers that bring the Microsoft ecosystem into your AI workflow. - [Mobbin MCP: Real Design Examples for AI Agents](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/mobbin-mcp/): Give your AI agent access to 620,000+ screens from shipped apps. Setup for Mobbin MCP across Cursor, Claude Code, and Codex -- plus Refero and other MCP servers that deliver design references. - [Jira and Linear MCP Integration](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/project-management/): Close the loop between tasks and code. Connect your AI to Jira or Linear via MCP to read ticket requirements, automate status updates, and manage your development workflow from your editor. - [Reducing MCP Token Cost with Code Execution](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/reducing-mcp-token-cost/): Loading every MCP tool definition into context burns tokens before you type a word. Learn the code-execution pattern that drops tool overhead by up to 98% across Cursor, Claude Code, and Codex. - [shadcn/ui MCP Server](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/shadcn-ui-mcp/): Install, customize, and compose shadcn/ui components with AI assistance. The official MCP server gives your AI access to the full component registry, documentation, and installation commands. - [Top 40 Community MCP Servers](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/top-community-servers/): A comprehensive field guide to the most valuable MCP servers in the ecosystem. From version control to monitoring, discover the servers that power modern AI-assisted development workflows. - [GitHub and GitLab MCP Integration](https://developertoolkit.ai/en/shared-workflows/mcp-ecosystem/version-control-mcp/): Let your AI read pull requests, search code across repos, manage issues, and understand your project's history. Set up GitHub and GitLab MCP servers for all three tools. - [Migration Strategy Center](https://developertoolkit.ai/en/shared-workflows/migration-playbooks/): Guides for transitioning teams and workflows to AI-assisted development with Cursor, Claude Code, and Codex — assessment, rollout, and project conversion. - [Migrating Between Codex, Cursor, and Claude Code](https://developertoolkit.ai/en/shared-workflows/migration-playbooks/from-codex/): Cross-tool migration between Codex, Cursor, and Claude Code: translating CLAUDE.md / AGENTS.md / .cursor/rules, mapping workflows, migrating MCP config, and running all three together. - [Migrating from GitHub Copilot](https://developertoolkit.ai/en/shared-workflows/migration-playbooks/from-copilot/): Move from GitHub Copilot's inline completions to the full agent workflows of Cursor, Claude Code, and Codex: feature and pricing comparison, a phased migration plan, and copy-paste prompts. - [Migrating from Traditional IDEs](https://developertoolkit.ai/en/shared-workflows/migration-playbooks/from-traditional-ide/): Move from VS Code, JetBrains, or Vim to AI-powered coding with Cursor, Claude Code, or Codex -- import your settings, keep your muscle memory, and shift to a describe-don't-write workflow. - [Migrating from Windsurf](https://developertoolkit.ai/en/shared-workflows/migration-playbooks/from-windsurf/): Moving from Windsurf IDE to Cursor, Claude Code, or Codex -- feature mapping, workflow translation, and configuration migration for a smooth transition. - [Project Conversion Playbook](https://developertoolkit.ai/en/shared-workflows/migration-playbooks/project-conversion/): Convert an existing codebase into an AI-ready project for Cursor, Claude Code, and Codex — context files, rules, and CI that the agent actually reads. - [Success Stories & Case Studies](https://developertoolkit.ai/en/shared-workflows/migration-playbooks/success-stories/): Real-world examples of teams and organizations successfully migrating to AI-powered development - [Team Migration Strategies](https://developertoolkit.ai/en/shared-workflows/migration-playbooks/team-migration-strategies/): Successfully transition entire teams and organizations to AI-powered development with proven rollout strategies - [Workflow Transformation Guide](https://developertoolkit.ai/en/shared-workflows/migration-playbooks/workflow-transformation/): Rebuild a traditional feature-delivery workflow around Cursor, Claude Code, and Codex without losing review discipline or shipping prototypes to prod. - [Introduction to Agent Skills](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/): Skills are reusable instruction sets that teach your AI coding agent how to work with your tools and workflows. Install with one command, share across your team, persist across sessions. - [Building and Publishing Your Own Skills](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/building-custom-skills/): Create custom agent skills with the right file structure (SKILL.md plus optional supporting files), test them locally, publish to GitHub, and list them on the skills.sh marketplace. - [Dr. Skill: Auditing Your Agent's Skill and MCP Loadout](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/drskill/): How drskill resolves what each coding agent actually loads, checks it against 34 issue categories, and reports which skills your agents really use -- without editing a single file. - [Grill Me & Grill With Docs: Align With Your Agent Before You Build](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/grill-me/): Two slash-command skills that interview you one question at a time until you and the agent share an understanding -- and, with docs, build a ubiquitous language and ADRs as you go. - [Impeccable: A Design Vocabulary for Your AI Harness](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/impeccable-design/): A free design skill pack that gives you and your AI the same words for hierarchy, contrast, and restraint -- all 23 commands explained one by one, direction-dealt new builds, a browser Live Mode, design hooks, and a 59-rule deterministic anti-slop detector for CI. - [Installing, Updating, and Managing Skills](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/installing-managing/): The skills CLI installs, updates, lists, and removes agent skills. Learn every command, where skill files live for each tool, and how to manage skills across a team. - [shadcn/improve: Audit With Your Best Model, Execute With a Cheap One](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/shadcn-improve/): An agent skill that uses your most capable model to audit a codebase and write implementation plans precise enough for cheaper models to execute without babysitting. - [Skill Supply-Chain Security](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/skill-security/): An Agent Skill is markdown that becomes your AI's instructions — so a malicious one is a prompt-injection payload you installed yourself. Scan, review, and scope skills before they reach your agent. - [Skills Optimization and Team Sharing](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/skills-best-practices/): Best practices for using skills effectively -- avoiding conflicts, standardizing across teams, version pinning, monitoring context usage, and security considerations for skill management. - [Skills vs MCP -- When to Use Which](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/skills-vs-mcp/): Skills and MCP servers both enhance your AI coding agent but solve different problems. A decision framework for when to reach for a skill versus an MCP server, with real examples. - [Superpowers: A Disciplined Development Workflow for Coding Agents](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/superpowers/): How obra/superpowers turns brainstorming, worktrees, implementation plans, TDD, subagents, code review, and verification into one disciplined agent workflow. - [Taste Skill: The Anti-Slop Frontend Skill Library](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/taste-skill/): How Leonxlnx/taste-skill constrains AI frontend generation up front -- brief inference, three dials, a hard anti-slop ban list, and 13 installable variants across every major coding agent. - [Best Skills for Backend and DevOps](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/top-skills-backend/): The most impactful agent skills for backend, infrastructure, security, and API workflows. Teach your AI production-grade backend patterns using real, battle-tested skills from the skills.sh ecosystem. - [Best Skills for Business and Product](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/top-skills-business/): Agent skills for design, marketing, sales, product strategy, and operations. Teach your AI established business frameworks -- from StoryBrand to Jobs to Be Done -- right in your workflow. - [Best Skills for Frontend Development](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/top-skills-frontend/): The most impactful agent skills for React, Next.js, Vue, Angular, Svelte, and frontend workflows. Each skill teaches your AI current best practices so it stops generating outdated patterns. - [Official Skills from Technology Makers](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/top-skills-official/): Skills published by the companies that build the technology. From Anthropic and Firebase to Stripe and Clerk -- official skills teach your AI the patterns the framework authors actually recommend. - [Best Skills for Workflow and Productivity](https://developertoolkit.ai/en/shared-workflows/skills-ecosystem/top-skills-productivity/): A curated guide to skills for planning, debugging, code review, git workflows, documentation, and browser automation. - [Testing Excellence with AI](https://developertoolkit.ai/en/shared-workflows/testing-quality/): Transform your testing strategy with AI-powered test generation, intelligent coverage analysis, and automated quality assurance across every testing layer. - [A11y Compliance Testing](https://developertoolkit.ai/en/shared-workflows/testing-quality/accessibility-testing/): Automate WCAG compliance testing with AI-powered accessibility auditing, screen reader validation, and inclusive design patterns. - [AI Code Review Checklist](https://developertoolkit.ai/en/shared-workflows/testing-quality/ai-code-review-checklist/): A practical 50+ point checklist for reviewing AI-generated code before production — scope, correctness, security, tests, and when to escalate to human review. - [API Test Automation](https://developertoolkit.ai/en/shared-workflows/testing-quality/api-testing/): Automate API testing with AI-generated contract tests, endpoint verification, and comprehensive request/response validation across REST and GraphQL APIs. - [End-to-End Test Automation](https://developertoolkit.ai/en/shared-workflows/testing-quality/e2e-testing/): Automate user journey testing with AI-generated Playwright and Cypress tests that catch real-world browser issues before your users do. - [Error Injection and Fault Injection Testing](https://developertoolkit.ai/en/shared-workflows/testing-quality/error-injection-testing/): Use Cursor, Claude Code, and Codex to inject faults, latency, and dependency failures so resilience patterns like timeouts, retries, and circuit breakers are proven before production. - [Integration Test Patterns](https://developertoolkit.ai/en/shared-workflows/testing-quality/integration-testing/): Generate robust integration tests with AI that verify real database interactions, API contracts, and service boundaries without the brittleness of mocks. - [Mobile App Testing Patterns](https://developertoolkit.ai/en/shared-workflows/testing-quality/mobile-testing/): Test mobile applications across platforms and devices with AI-powered test generation for React Native, Flutter, and native iOS/Android apps. - [Load, Stress, and Benchmark Testing](https://developertoolkit.ai/en/shared-workflows/testing-quality/performance-testing/): Build AI-assisted performance testing pipelines with load testing, stress testing, and continuous benchmarking that catch regressions before production. - [Security Scanning and Vulnerability Testing](https://developertoolkit.ai/en/shared-workflows/testing-quality/security-testing/): Automate security testing with AI-powered vulnerability scanning, dependency auditing, and penetration testing patterns that catch threats before deployment. - [Test Data Strategies and Fixtures](https://developertoolkit.ai/en/shared-workflows/testing-quality/test-data-management/): Build maintainable test data infrastructure with AI-generated factories, realistic fixtures, and privacy-compliant data generation strategies. - [Unit Test Strategies and Generation](https://developertoolkit.ai/en/shared-workflows/testing-quality/unit-testing/): Generate production-quality unit tests with AI that catch real bugs through behavior-driven testing, intelligent mocking, and mutation-verified coverage. ## Cookbook - [AI Developer Cookbook](https://developertoolkit.ai/en/cookbook/): Recipe collection -- 190+ copy-paste prompts for Cursor, Claude Code, and Codex across every major stack - [Backend Recipes](https://developertoolkit.ai/en/cookbook/backend-recipes/): Backend development patterns and best practices with AI-powered coding assistants - [API Development Patterns](https://developertoolkit.ai/en/cookbook/backend-recipes/api-patterns/): Design REST and GraphQL APIs with Cursor, Claude Code, and Codex — copy-paste prompts for idempotent endpoints, cursor pagination, auth, and OpenAPI generation. - [Database Development Patterns](https://developertoolkit.ai/en/cookbook/backend-recipes/database-patterns/): Optimize slow queries and run zero-downtime migrations with Cursor, Claude Code, and Codex — copy-paste prompts for Postgres EXPLAIN plans, expand/contract, and N+1 fixes. - [Elixir/Phoenix Recipes](https://developertoolkit.ai/en/cookbook/backend-recipes/elixir-patterns/): 10 copy-paste prompts for building fault-tolerant Elixir applications with Phoenix, Ecto, and OTP - [Go Language Patterns](https://developertoolkit.ai/en/cookbook/backend-recipes/go-patterns/): AI prompts and workflows for shipping production Go services — concurrency without goroutine leaks, pgx pools that survive load, and table-driven tests. - [Java & Spring Boot Patterns](https://developertoolkit.ai/en/cookbook/backend-recipes/java-patterns/): Production Spring Boot workflows with Cursor, Claude Code, and Codex -- copy-paste prompts for REST APIs, JPA, resilience, security, and testing. - [Node.js/Express Recipes](https://developertoolkit.ai/en/cookbook/backend-recipes/node-patterns/): 12 copy-paste prompts for building production Node.js backends with Express, Fastify, and TypeScript across Cursor, Claude Code, and Codex. - [PHP Development Patterns](https://developertoolkit.ai/en/cookbook/backend-recipes/php-patterns/): Modern PHP development with AI assistance for Laravel, Symfony, and enterprise applications - [Python Workflow Recipes](https://developertoolkit.ai/en/cookbook/backend-recipes/python-patterns/): 12 copy-paste prompts for building production Python backends with FastAPI, Django, and async patterns across Cursor, Claude Code, and Codex. - [Rust Development Patterns](https://developertoolkit.ai/en/cookbook/backend-recipes/rust-patterns/): Use Cursor, Claude Code, and Codex to win the borrow-checker fight, write compile-safe SQLx queries, and ship memory-safe async Rust services. - [Serverless Development Patterns](https://developertoolkit.ai/en/cookbook/backend-recipes/serverless-patterns/): Ship production serverless on AWS Lambda, Cloudflare Workers, and Vercel with Cursor, Claude Code, and Codex — cold-start fixes, idempotent handlers, and copy-paste prompts. - [Database Migration Patterns](https://developertoolkit.ai/en/cookbook/database-recipes/migration-patterns/): Drive zero-downtime schema migrations with Cursor, Claude Code, and Codex — expand-contract prompts, a read-only Postgres MCP server, and a real rollback recipe. - [NoSQL Patterns and Strategies](https://developertoolkit.ai/en/cookbook/database-recipes/nosql-patterns/): Design and optimize NoSQL data models with Cursor, Claude Code, and Codex — document, key-value, graph, and vector patterns for MongoDB, DynamoDB, and Neo4j, with copy-paste prompts. - [ORM Best Practices](https://developertoolkit.ai/en/cookbook/database-recipes/orm-patterns/): Use Cursor, Claude Code, and Codex to design type-safe Prisma and TypeORM schemas, kill N+1 queries, write safe transactions, and ship zero-downtime migrations. - [SQL Optimization Patterns](https://developertoolkit.ai/en/cookbook/database-recipes/sql-patterns/): AI-powered SQL query optimization with database MCP servers — read execution plans, design indexes, and rewrite slow queries for Postgres and MySQL. - [DevOps & Infrastructure Recipes](https://developertoolkit.ai/en/cookbook/devops-recipes/): Automate deployment, containerization, and infrastructure management with AI-powered DevOps - [CI/CD Pipeline Patterns](https://developertoolkit.ai/en/cookbook/devops-recipes/ci-cd-pipelines/): Generate and harden GitHub Actions, GitLab CI, and Jenkins pipelines with Cursor, Claude Code, and Codex - matrix builds, image scanning, and gated deploys. - [Docker & Container Patterns](https://developertoolkit.ai/en/cookbook/devops-recipes/docker-patterns/): Build, optimize, and ship production Docker containers with Cursor, Claude Code, and Codex — multi-stage builds, image hardening, Compose orchestration, and CI/CD scanning. - [Infrastructure as Code Patterns](https://developertoolkit.ai/en/cookbook/devops-recipes/infrastructure-as-code/): Use Cursor, Claude Code, and Codex to write, refactor, and review Terraform, CloudFormation, and Pulumi without shipping drift, secrets, or 500-line blast radii. - [Kubernetes Orchestration Patterns](https://developertoolkit.ai/en/cookbook/devops-recipes/kubernetes-patterns/): Generate production-ready Kubernetes manifests, Helm charts, GitOps configs, and autoscaling with Cursor, Claude Code, and Codex — plus copy-paste prompts and failure-recovery playbooks. - [Monitoring & Logging Patterns](https://developertoolkit.ai/en/cookbook/devops-recipes/monitoring-logging/): AI-assisted observability recipes — instrument services with OpenTelemetry, write Prometheus alerts and Logstash pipelines, and debug live incidents through MCP. - [Error Handling Recipes](https://developertoolkit.ai/en/cookbook/error-handling-recipes/): Debugging, logging, monitoring, and recovery patterns with AI-powered coding assistants - [Debugging Patterns](https://developertoolkit.ai/en/cookbook/error-handling-recipes/debugging-patterns/): Systematic AI-assisted debugging for intermittent auth failures, race conditions, memory leaks, and cross-service traces across Cursor, Claude Code, and Codex. - [Logging Patterns](https://developertoolkit.ai/en/cookbook/error-handling-recipes/logging-patterns/): Use Cursor, Claude Code, and Codex to refactor console.log into structured, correlated, secret-safe logging you can actually query in production. - [Monitoring Patterns](https://developertoolkit.ai/en/cookbook/error-handling-recipes/monitoring-patterns/): Use Cursor, Claude Code, and Codex to generate, audit, and ship production monitoring — golden-signal alerts, SLO burn-rate rules, and dashboards. - [Recovery Patterns](https://developertoolkit.ai/en/cookbook/error-handling-recipes/recovery-patterns/): Use Cursor, Claude Code, and Codex to add circuit breakers, jittered retries, and fallbacks with real libraries — then prove they work with a chaos test. - [Angular Development Recipes](https://developertoolkit.ai/en/cookbook/frontend-recipes/angular-patterns/): 12 copy-paste prompts for building Angular applications with signals, standalone components, and RxJS - [React Native and Flutter UI Recipes](https://developertoolkit.ai/en/cookbook/frontend-recipes/mobile-patterns/): 12 copy-paste prompts for building cross-platform mobile UI with React Native and Flutter - [Next.js Optimization Recipes](https://developertoolkit.ai/en/cookbook/frontend-recipes/nextjs-patterns/): 12 copy-paste prompts for building and optimizing Next.js App Router applications with RSC, streaming, and edge - [Nuxt 3 Development Recipes](https://developertoolkit.ai/en/cookbook/frontend-recipes/nuxt-patterns/): 12 copy-paste prompts for building full-stack Nuxt 3 applications with server routes, composables, and edge deployment - [React Development Recipes](https://developertoolkit.ai/en/cookbook/frontend-recipes/react-patterns/): 15 copy-paste prompts for building production React apps with Cursor, Claude Code, and Codex - [Vue.js Workflow Recipes](https://developertoolkit.ai/en/cookbook/frontend-recipes/vue-patterns/): 12 copy-paste prompts for building Vue 3 applications with Composition API, Pinia, and TypeScript - [Mobile Development](https://developertoolkit.ai/en/cookbook/mobile-development/): React Native, Flutter, and Expo mobile development recipes with AI coding assistants - [Expo Development Patterns](https://developertoolkit.ai/en/cookbook/mobile-development/expo/): Production Expo workflows with Cursor, Claude Code, and Codex - Expo Router, NativeWind, EAS Build, push notifications, and offline-first patterns. - [Flutter Development Patterns](https://developertoolkit.ai/en/cookbook/mobile-development/flutter/): Production Flutter workflows with Cursor, Claude Code, and Codex - Riverpod state, go_router navigation, Dio networking, clean architecture, and widget tests. - [React Native Development Patterns](https://developertoolkit.ai/en/cookbook/mobile-development/react-native/): Production React Native workflows with Cursor, Claude Code, and Codex - Expo scaffolding, navigation, offline-first state, FlatList performance, RNTL testing, and iOS/Android CI/CD. ## Deployment & Operations - [Deployment & Operations](https://developertoolkit.ai/en/deployment-operations/): Security operations, compliance automation, cost optimization, CI/CD, monitoring, and incident response for AI-assisted development workflows - [Compliance Automation with AI](https://developertoolkit.ai/en/deployment-operations/compliance-automation/): Use Cursor, Claude Code, and Codex to generate SOC 2 evidence scripts, license and secret-scan CI gates, and GDPR data-flow docs straight from your codebase. - [Cost Optimization with AI](https://developertoolkit.ai/en/deployment-operations/cost-optimization/): Drive Cursor, Claude Code, and Codex with the AWS Billing & Cost Management MCP to find idle resources, rightsize infrastructure, and forecast spend. - [Security Operations with AI](https://developertoolkit.ai/en/deployment-operations/security-operations/): An AI-assisted DevSecOps loop that triages scanner noise, separates exploitable findings from false positives, and ships fixes as reviewed PRs. ## Developer Scorecard Guide - [Developer Scorecard Guide](https://developertoolkit.ai/en/developer-scorecard-guide/): How to reach max score on every question in the AI Developer Scorecard — 25 implementation playbooks for the 2026 frontier. - [Agent hooks — the only way to enforce 'every time X'](https://developertoolkit.ai/en/developer-scorecard-guide/agent-hooks/): How to reach max score on Q13 of the AI Developer Scorecard: run 5+ orchestrated hooks (auto-PR-watch, fix-on-review, MCP guards) across Claude Code, Cursor, and Codex CLI. - [Agent memory — typed entries that survive every session](https://developertoolkit.ai/en/developer-scorecard-guide/agent-memory/): How to reach max score on Q5 of the Developer Scorecard by deliberately using typed memory (user / feedback / project / reference) and pruning stale entries. - [Agent skills — install from marketplaces and author your own](https://developertoolkit.ai/en/developer-scorecard-guide/agent-skills/): The top‑tier answer to scorecard Q8 is authoring your own SKILL.md files — and combining skills.sh marketplace installs with custom skills for a compounding, cross‑tool setup. - [Auto-PR workflow — Stop hook that ships and wakes you on review](https://developertoolkit.ai/en/developer-scorecard-guide/auto-pr-workflow/): How to reach max score on Q16 of the AI Developer Scorecard: a Stop hook that auto-opens the PR when work finishes and re-wakes the agent when reviewers, bots, or CI come back with feedback. - [Building your own MCP server — when to MCP vs skill vs slash command](https://developertoolkit.ai/en/developer-scorecard-guide/building-mcp-servers/): How to reach max score on Q11 of the AI Developer Scorecard: build, ship and route between several MCP servers, picking MCP vs skill vs slash command per use case. - [CLAUDE.md / AGENTS.md — layered context that survives every session](https://developertoolkit.ai/en/developer-scorecard-guide/claude-md-context/): Tiered hierarchy (global → project → .claude/rules/) is the cheapest, highest-leverage way to make every Claude Code or Codex session start informed. - [Cost monitoring — alerts, hard caps, and cheap-model routing](https://developertoolkit.ai/en/developer-scorecard-guide/cost-monitoring/): Max score on Q21 of the AI Developer Scorecard: install token-usage dashboards, set hard caps and alerts in the Anthropic Console, and route expensive loops to Haiku and Sonnet. - [Custom slash commands — one-keystroke skills shared via repo](https://developertoolkit.ai/en/developer-scorecard-guide/custom-slash-commands/): Why the top-tier answer to scorecard Q7 is 8+ custom slash commands shared with the team via repo — and how to build a slash-command library in Claude Code, Cursor, and Codex without over-engineering. - [Custom subagents — protect context with specialized delegates](https://developertoolkit.ai/en/developer-scorecard-guide/custom-subagents/): Max score on Q12 of the AI Developer Scorecard: a full set of code-reviewer, code-explorer, and code-architect subagents that protect main-context budget and parallelize research. - [Setup portability — dotfiles repo + bootstrap script](https://developertoolkit.ai/en/developer-scorecard-guide/dotfiles-portability/): How to score max on Q23 of the AI Developer Scorecard: keep ~/.claude, ~/.codex, ~/.agents, ~/.cursor in a versioned dotfiles repo with a one-line bootstrap script. - [Agent-driven E2E — the agent runs the browser before saying 'done'](https://developertoolkit.ai/en/developer-scorecard-guide/e2e-agent-verification/): Why the max-score answer to scorecard Q18 is the agent running E2E (Playwright MCP, browser-harness) to verify the feature — and how to wire it into a Stop hook so UI work never ships unverified. - [git worktrees — one filesystem per agent, no collisions](https://developertoolkit.ai/en/developer-scorecard-guide/git-worktrees/): How to reach max score on Q15 of the AI Developer Scorecard: a worktree-per-agent workflow (Conductor, Claude Squad, or a thin script) so parallel agents never step on each other's files. - [Keeping up — active sources beat passive feeds](https://developertoolkit.ai/en/developer-scorecard-guide/keeping-up-with-tools/): Why scorecard Q24 demands active sources — Discord, courses, weekly sandbox experiments — and how to build a stay-current habit that survives the 3-month half-life of AI coding best practice. - [Layered PR review — because AI PRs ship 1.7× more issues](https://developertoolkit.ai/en/developer-scorecard-guide/layered-pr-review/): How to reach max score on Q17 of the Developer Scorecard by stacking multiple specialized AI reviewers plus a custom /review and a multi-agent /ultrareview on every PR. - [Up-to-date library docs — Context7 + a routing skill](https://developertoolkit.ai/en/developer-scorecard-guide/library-docs-context7/): The top answer to scorecard Q20 is Context7 MCP plus a skill that auto-decides 'library lookup vs general programming' — install both so your agent stops hallucinating nonexistent APIs. - [Essential MCP trio — the 3 servers that cover most workflows](https://developertoolkit.ai/en/developer-scorecard-guide/mcp-essential-trio/): The top-scoring answer to scorecard Q10 is GitHub MCP + Context7 + Figma (Sentry/Linear are situational) — and how to install the trio without falling for hallucinated packages or wrong endpoints. - [MCP server count — 3-5 well-matched, not 15 of everything](https://developertoolkit.ai/en/developer-scorecard-guide/mcp-server-count/): Why the top-tier answer to scorecard Q9 is 3-5 MCP servers chosen for fit, not maximum count — and how to audit and prune a bloated MCP stack without losing the integrations you actually use. - [Model routing — Opus/Sonnet/Haiku per task](https://developertoolkit.ai/en/developer-scorecard-guide/model-routing/): How to reach max score on Q3 of the AI Developer Scorecard: mix Claude Opus 5, Sonnet 5, and Haiku 4.5 inside one session, with GPT-5.6 Sol and Gemini as cross-vendor fallbacks. - [Plan mode — default gate for every non-trivial change](https://developertoolkit.ai/en/developer-scorecard-guide/plan-mode/): How to reach max score on Q6 of the Developer Scorecard by making Plan mode the default for every non‑trivial change — research, gate, then execute. - [Primary AI coding tool — going terminal/agent-first](https://developertoolkit.ai/en/developer-scorecard-guide/primary-ai-tool/): Why the top‑tier answer to scorecard Q1 is Claude Code, Codex CLI, or Cursor Agents — and how to migrate from web‑chat or IDE‑autocomplete tooling without losing productivity. - [Secrets management — 1Password/doppler + scoped tokens + quarterly audit](https://developertoolkit.ai/en/developer-scorecard-guide/secrets-management/): How to max Q22 of the AI Developer Scorecard: route every secret through a manager (1Password CLI or Doppler), give each agent a scoped token, and audit access quarterly. - [Structuring a non-trivial change — Explore → Plan → code → PR → review-fix](https://developertoolkit.ai/en/developer-scorecard-guide/structuring-changes/): How to max Q25 of the AI Developer Scorecard: run every non-trivial change as parallel Explore subagents → Plan mode → code → auto-PR → review-fix loop. The agent's confidence is not correctness. - [Subscription plan fit — sizing for parallel agents](https://developertoolkit.ai/en/developer-scorecard-guide/subscription-plan-fit/): How to pick between Pro, Max, Ultra, and Business plans for AI coding — and why the top tier pays back fast for terminal/agent‑first users. - [Vibe-coding policy — Lovable/Bolt/v0 for MVPs, Cursor/Claude for production](https://developertoolkit.ai/en/developer-scorecard-guide/vibe-coding-policy/): Why the top-tier answer to scorecard Q19 is a deliberate per-task policy — vibe-coding tools for MVPs and lead magnets, terminal agents for production — and how to write yours. - [Workflow tier — from one session to autonomous overnight runs](https://developertoolkit.ai/en/developer-scorecard-guide/workflow-tier/): How to reach max score on Q14 of the AI Developer Scorecard: graduate from one IDE session to 2–4 parallel agents to autonomous overnight backlog drains on Codex Cloud and Cursor Cloud Agents. ## CTO Scorecard Guide - [CTO Scorecard Guide](https://developertoolkit.ai/en/cto-scorecard-guide/): How to reach max score on every question in the CTO AI Maturity Scorecard — 25 implementation playbooks for Reactive → Strategic Leader. - [AI in CI/CD — agent in the path of every commit](https://developertoolkit.ai/en/cto-scorecard-guide/ai-in-cicd/): How to reach max score on Q13 of the CTO Scorecard: a full four-phase AI pipeline where agents generate, review, test, and deploy — gated by hard policy, not by good intentions. - [AI metrics panel — 6 numbers every CTO should track](https://developertoolkit.ai/en/cto-scorecard-guide/ai-metrics-panel/): How to reach max score on Q22 of the CTO Scorecard: spend, throughput, quality, adoption, review-to-merge time, and cost-per-feature on a single dashboard. - [AI-PR labelling — distinguish + apply extra gates](https://developertoolkit.ai/en/cto-scorecard-guide/ai-pr-labeling/): How to reach max score on Q11 of the CTO AI Maturity Scorecard: auto-label AI-authored pull requests and route them through extra gates — full test suite + SAST/SCA security scan + 2× human review. - [AI tooling roadmap — 6-12 month plan + dedicated lead](https://developertoolkit.ai/en/cto-scorecard-guide/ai-tooling-roadmap/): How to reach the max-score answer on CTO Scorecard Q24: a real 6-12 month AI tooling roadmap owned by a dedicated platform-engineer-for-AI lead or team with a real budget. - [Compliance policy — allowlist + audit + PII scrubbers + DPAs + GDPR/HIPAA](https://developertoolkit.ai/en/cto-scorecard-guide/compliance-policy/): How to reach max score on Q21 of the CTO Scorecard: a five-layer compliance policy for AI prompts covering model allowlists, vendor DPAs, PII scrubbers, audit logging, and GDPR/HIPAA mapping. - [Cost visibility — full FinOps for token spend](https://developertoolkit.ai/en/cto-scorecard-guide/cost-visibility/): How to reach the max-score answer on CTO Scorecard Q4: per-dev + per-repo + per-PR token spend with model tagging, alerts, and hard caps. - [Dev onboarding time — sub-day setup with bootstrap script](https://developertoolkit.ai/en/cto-scorecard-guide/dev-onboarding-time/): Reach max score on CTO Scorecard Q19: a bootstrap script (CLAUDE.md, hooks, skills, MCP) plus a buddy and day-1 sample sessions get a new hire to a merged PR before they go home. - [E2E policy — required + agent runs browser tests before merge](https://developertoolkit.ai/en/cto-scorecard-guide/e2e-policy/): The 2026 max-score answer for UI changes: mandatory E2E plus an agent that drives a real browser before merge. Roll it out with Playwright MCP, chrome-devtools MCP, and PR-gated runs. - [Gates vs guardrails — design-time policy beats per-PR review](https://developertoolkit.ai/en/cto-scorecard-guide/gates-vs-guardrails/): Reach max score on Q10 of the CTO Scorecard: shift from per-PR gates that burn human bandwidth to design-time guardrails in managed CLAUDE.md, skills, and hooks the AI cannot route around. - [Internal MCP servers — MCP platform team for the org](https://developertoolkit.ai/en/cto-scorecard-guide/internal-mcp-servers/): Why the top-scoring answer to CTO Scorecard Q7 is 'multiple internal MCPs + owner + docs + monitoring' — and how to ship your first internal MCP without building a one-off toy nobody maintains. - [Knowledge sharing — ai-toolkit-internal repo + brown-bag cadence](https://developertoolkit.ai/en/cto-scorecard-guide/knowledge-sharing/): The half-life of an AI-tooling best practice in 2026 is ~3 months. A company-wide ai-toolkit-internal repo plus a brown-bag cadence keeps a team from re-learning the same lessons every quarter. - [MCP security — allowlist + scoped tokens + log audit + red-team](https://developertoolkit.ai/en/cto-scorecard-guide/mcp-security/): Why CTO Scorecard Q8 hinges on treating MCP as a privileged execution context — and how to build the four-layer model (allowlist + scoped tokens + audit log + red-team) that bounds blast radius. - [Plan mode policy — hook + managed policy enforces planning before destructive changes](https://developertoolkit.ai/en/cto-scorecard-guide/plan-mode-policy/): Memory can't enforce 'every time X' — only the harness can. A PreToolUse hook plus an org-wide managed policy blocks edits to migrations, terraform, and auth without an approved Plan-mode plan. - [ROI measurement — annual dashboard with pre-AI baseline](https://developertoolkit.ai/en/cto-scorecard-guide/roi-measurement/): Reach the max-score answer on CTO Scorecard Q23: an annual ROI dashboard with pre-AI baseline vs current, $/dev saved, and headcount equivalent — the artifact that survives a budget challenge. - [Shared agent rules — managed policy + per-repo CLAUDE.md + .claude/rules/](https://developertoolkit.ai/en/cto-scorecard-guide/shared-agent-rules/): Three-tier rule hierarchy (managed policy, per-repo CLAUDE.md/AGENTS.md, .claude/rules/ per area) plus a quarterly audit is what separates 'tribal knowledge' from 'the harness enforces it'. - [Shared hooks governance — repo + bootstrap + signing](https://developertoolkit.ai/en/cto-scorecard-guide/shared-hooks-governance/): Hooks run code on every tool call, so unaudited hook drift is a supply-chain risk. The max-score answer: a hooks repo auto-installed via dotfiles bootstrap, with signed and audited hook scripts. - [Shared skills — company repo + bootstrap + onboarding hook](https://developertoolkit.ai/en/cto-scorecard-guide/shared-skills/): A company skill repo + bootstrap script + SessionStart auto-install turns 'knows how to refactor our auth' into a one-liner every teammate can run. - [Team adoption rate — crossing 70% to unlock compounding](https://developertoolkit.ai/en/cto-scorecard-guide/team-adoption-rate/): Why <30% AI tool adoption burns money and >70% unlocks compounding leverage. How CTOs measure active use, coach laggards, and prove ROI in 2026. - [Team billing — Team/Enterprise plans with centralized audit](https://developertoolkit.ai/en/cto-scorecard-guide/team-billing/): Why consolidated Team/Enterprise plans (Anthropic, Cursor, OpenAI Business) with SSO, SCIM, and centralized audit are 2026 table stakes — and how to migrate a team off personal reimbursement. - [Team parallelism (Tier 2) — measured concurrency with solved merge patterns](https://developertoolkit.ai/en/cto-scorecard-guide/team-parallelism-tier2/): How to calibrate concurrent Claude/Codex agents per developer, isolate them with worktrees, and operate a measurable merge playbook. - [Team PR review automation — layered AI reviewers + ultrareview](https://developertoolkit.ai/en/cto-scorecard-guide/team-pr-review-automation/): How to reach max score on Q9 of the CTO Scorecard: multiple AI reviewers on every PR (CodeRabbit/Greptile + Claude Code Action / Codex / Sentry Seer) plus ultrareview multi-agent for sensitive diffs. - [Team vibe-coding policy — per-tier rules with graduation criteria](https://developertoolkit.ai/en/cto-scorecard-guide/team-vibe-coding-policy/): Why the max-score answer to Q16 of the CTO Scorecard is a per-tier policy — vibe-coding for MVPs/lead magnets, Cursor/Claude Code for production, with explicit graduation criteria you can write. - [Tier 3 overnight runs — curated backlog + scheduled + review-on-arrival](https://developertoolkit.ai/en/cto-scorecard-guide/tier3-overnight-runs/): How to score 3 points on Q15: a curated 'AI eligible' backlog, scheduled overnight runs on Codex Cloud or Cursor Cloud Agents, and a review-on-arrival ritual that absorbs the PRs instead of drowning. - [Tooling policy — standardized stack with an exception process](https://developertoolkit.ai/en/cto-scorecard-guide/tooling-policy/): How to write an AI coding tool policy that beats Shadow AI without strangling experimentation: a short preferred stack, a real exception process, and a quarterly review cadence. - [Vendor risk management — multi-vendor + abstraction + DR plan](https://developertoolkit.ai/en/cto-scorecard-guide/vendor-risk-management/): Multi-vendor LLM allowlists behind a router or gateway (OpenRouter, Bedrock, Vertex, LiteLLM) plus a tested DR runbook for rate-limit storms and vendor outages. ## Resources - [Additional Resources](https://developertoolkit.ai/en/resources/): Essential resources, references, and community links for mastering AI-assisted development with Cursor, Claude Code, and Codex - [Community Resources](https://developertoolkit.ai/en/resources/community/): Discord servers, forums, GitHub repos, and social channels for the Cursor, Claude Code, and Codex communities - [Frequently Asked Questions](https://developertoolkit.ai/en/resources/faq/): Answers to the most common questions about Cursor, Claude Code, and Codex -- setup, pricing, models, and daily workflow - [Provide Feedback](https://developertoolkit.ai/en/resources/feedback/): Report bugs and request features for Cursor, Claude Code, and Codex with the diagnostics maintainers actually need, plus how to contribute to this guide. - [Glossary of AI Development Terms](https://developertoolkit.ai/en/resources/glossary/): Comprehensive definitions of 50+ terms used in AI-assisted development with Cursor, Claude Code, and Codex - [Learning Paths](https://developertoolkit.ai/en/resources/learning-paths/): Structured week-by-week learning journeys for mastering Cursor, Claude Code, and Codex at beginner, intermediate, and expert levels - [Troubleshooting Guide](https://developertoolkit.ai/en/resources/troubleshooting/): Common issues and step-by-step fixes for Cursor, Claude Code, and Codex, plus MCP and recovery tips. - [Latest Updates](https://developertoolkit.ai/en/resources/updates/): Release notes, model changes, and feature announcements across Cursor, Claude Code, and Codex - [What's New on AI Developer Toolkit](https://developertoolkit.ai/en/resources/whats-new/): Documentation changelog for developertoolkit.ai: new guides, lessons and content updates for Cursor, Claude Code and Codex. ## Appendices - [Appendices](https://developertoolkit.ai/en/appendices/): Reference guides, command cheat sheets, keyboard shortcuts, and configuration references for AI coding tools - [Command Reference Cheatsheet](https://developertoolkit.ai/en/appendices/command-reference/): Every CLI command, slash command, and context symbol across Cursor, Claude Code, and Codex - [Configuration Reference](https://developertoolkit.ai/en/appendices/config-reference/): Side-by-side comparison of .cursor/rules, CLAUDE.md, AGENTS.md, and codex config.toml with complete syntax and examples - [Keyboard Shortcuts Reference](https://developertoolkit.ai/en/appendices/keyboard-shortcuts/): Complete keyboard shortcut tables for Cursor, Claude Code, and Codex, plus platform notes and customization tips to keep your hands off the mouse. - [Tool Migration Checklist](https://developertoolkit.ai/en/appendices/migration-checklist/): A step-by-step checklist for migrating to or between Cursor, Claude Code, and Codex: assess, pilot, roll out, and optimize without losing velocity. - [AI Model Comparison Guide](https://developertoolkit.ai/en/appendices/model-comparison/): Verified specifications, pricing, and routing guidance for Claude Opus 5, Fable 5 and Sonnet 5, GPT-5.6 Sol/Terra/Luna, Gemini 3.1 Pro, Grok 4.5 and Cursor Composer 2.5. - [Pricing Calculator](https://developertoolkit.ai/en/appendices/pricing-calculator/): A source-backed worksheet for Cursor, Claude Code, and Codex subscription, credit, and API costs - [Documentation Update Tracker](https://developertoolkit.ai/en/appendices/update-tracker/): Content versioning log and update history for the AI Developer Toolkit Guide, tracking model, pricing, and feature changes across Cursor, Claude Code, and Codex. ## Free pages (no account required) - [Compare AI Coding Tools](https://developertoolkit.ai/en/compare/): Cursor, Claude Code and Codex compared side by side: interface, agents, models, safety and price, with a plain verdict on each pairing and links into the documentation. - [Cursor vs Claude Code vs Codex](https://developertoolkit.ai/en/compare/best-ai-coding-tools/): Cursor, Claude Code and Codex compared side by side on interface, agents, models, safety and price — with a plain answer to which one to start with. - [Cursor vs Claude Code](https://developertoolkit.ai/en/compare/cursor-vs-claude-code/): Cursor and Claude Code compared on interface, agent capability, models and price. A side-by-side table, a plain verdict, and when experienced developers run 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. Where hooks and subagents beat native GitHub reviews, and where they do not. - [Cursor vs Codex](https://developertoolkit.ai/en/compare/cursor-vs-codex/): Cursor and OpenAI Codex compared on interface, models, integrations and price. One puts AI in your editor; the other puts an agent in GitHub, Slack and the cloud. - [Cursor vs GitHub Copilot](https://developertoolkit.ai/en/compare/cursor-vs-github-copilot/): GitHub Copilot predicts the next lines; Cursor plans and executes multi-file changes. The difference is architectural, not incremental — here is what that means day to day. - [AI Coding Glossary](https://developertoolkit.ai/en/glossary/): Twelve terms you meet in the first hour with Cursor, Claude Code or Codex — MCP, CLAUDE.md, context windows, plan mode, sub-agents and more — each defined and compared per tool. - [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 servers. - [What is AGENTS.md?](https://developertoolkit.ai/en/glossary/agents-md/): AGENTS.md is the repository 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, how it is created, and how it relates to AGENTS.md. - [What is a context window?](https://developertoolkit.ai/en/glossary/context-window/): A context window is how much text a model can process at once, in tokens. Current limits across Claude, GPT-5.6 and Gemini, and why the effective window is often smaller. - [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 before using it. - [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 Anthropic’s open standard for connecting AI coding agents to external tools and data. What an MCP server is, and how Cursor, Claude Code and Codex each configure one. - [What is plan mode?](https://developertoolkit.ai/en/glossary/plan-mode/): Plan mode makes an AI agent produce a structured plan before it edits anything. How to enter it in Claude Code, and how Cursor and Codex expose the same phase. - [What is a sandbox?](https://developertoolkit.ai/en/glossary/sandbox/): A sandbox limits what an AI agent’s commands can touch. How Codex separates sandbox policy from approval, and what Claude Code and Cursor offer instead. - [What are slash commands?](https://developertoolkit.ai/en/glossary/slash-commands/): Slash commands trigger built-in and custom actions in AI coding agents. Which ones Claude Code and Codex ship, and why typing / is the only reliable inventory. - [What is a sub-agent?](https://developertoolkit.ai/en/glossary/subagents/): A sub-agent is a separate AI instance spawned to handle one subtask in its own context window. How Cursor, Claude Code and Codex each run them, and when it pays off. - [AI Coding by Role](https://developertoolkit.ai/en/for/): What adopting an AI coding agent actually changes for backend, frontend, mobile and DevOps engineers, solo builders, tech leads and CTOs — with recipes for each. - [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 development, 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/): Running AI coding agents in CI, and the guardrails that make it safe: sandbox policy, hooks, headless mode — plus recipes for Docker, Kubernetes and IaC. - [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 posture and the numbers to ask for instead of a productivity promise. ## Languages - English: https://developertoolkit.ai/en/ - Polish: https://developertoolkit.ai/pl/ ## Full documentation for AI systems - [All English docs, single file](https://developertoolkit.ai/llms-full.txt): ~5 MB — prefer the per-section files below if your context is limited - [All Polish docs, single file](https://developertoolkit.ai/llms-full-pl.txt) - [Introduction (section file)](https://developertoolkit.ai/llms/introduction.txt) - [Tool Comparison (section file)](https://developertoolkit.ai/llms/comparison.txt) - [Claude Code (section file)](https://developertoolkit.ai/llms/claude-code.txt) - [Cursor IDE (section file)](https://developertoolkit.ai/llms/cursor-ide.txt) - [OpenAI Codex (section file)](https://developertoolkit.ai/llms/codex.txt) - [Shared Workflows (section file)](https://developertoolkit.ai/llms/shared-workflows.txt) - [Cookbook (section file)](https://developertoolkit.ai/llms/cookbook.txt) - [Deployment & Operations (section file)](https://developertoolkit.ai/llms/deployment-operations.txt) - [Developer Scorecard Guide (section file)](https://developertoolkit.ai/llms/developer-scorecard-guide.txt) - [CTO Scorecard Guide (section file)](https://developertoolkit.ai/llms/cto-scorecard-guide.txt) - [Resources (section file)](https://developertoolkit.ai/llms/resources.txt) - [Appendices (section file)](https://developertoolkit.ai/llms/appendices.txt) ## Optional - [Compare AI coding tools](https://developertoolkit.ai/en/compare/) - [Pricing](https://developertoolkit.ai/pricing) - [Pricing (machine-readable)](https://developertoolkit.ai/pricing.md) - [About](https://developertoolkit.ai/about) - [Roadmap](https://developertoolkit.ai/roadmap) - [Sitemap](https://developertoolkit.ai/sitemap-index.xml)