Agentic coding is the emerging software development paradigm where AI agents autonomously write, edit, test, and refactor code while developers shift into supervisory and architectural roles. Rather than using AI as an autocomplete tool, agentic coding treats AI as an autonomous collaborator that executes multi-step engineering tasks — from implementing features to resolving GitHub issues — with human oversight at key decision points.

The agentic workflow follows a delegation and review cycle:

1. Specify — Developer writes a task description, spec file, or points to a GitHub issue
2. Delegate — Agent analyzes the codebase, plans implementation, and begins coding in a sandboxed environment
3. Monitor — Developer observes progress through dashboards or terminal output
4. Review — Agent presents changes for approval; developer reviews diffs and provides feedback
5. Iterate — Agent incorporates feedback and continues until the task passes tests and review

Agents perform best with clear behavioral contracts. Teams use spec files to define agent behavior:

# Example: requirements.md that guides an agent
REQUIREMENTS = """
## Task: Add user authentication
 
### Constraints
- Use existing database models, do not create new tables
- Follow the repository's existing patterns for middleware
- All endpoints must require authentication except /health and /login
- Write tests for each new endpoint
 
### Acceptance Criteria
- [ ] POST /login returns JWT token
- [ ] Protected routes return 401 without valid token
- [ ] Tests cover happy path and error cases
- [ ] No existing tests are broken
 
### Anti-patterns to avoid
- Do not hardcode secrets
- Do not use deprecated auth libraries
- Do not modify unrelated files
"""
 
# Agent reads this spec and implements accordingly
# Developer reviews the resulting PR

Files like AGENTS.md, requirements.md, or tasks.md serve as durable contracts that prevent agent drift and ensure consistent behavior across sessions.

Agentic coding evolves pair programming from real-time collaboration to a supervisory model:

• Developer provides — High-level intent, architectural decisions, edge case awareness, domain knowledge
• Agent provides — Implementation speed, codebase exploration, test writing, boilerplate handling
• Shared responsibility — Code quality, correctness, and maintainability

The developer's role shifts from writing every line to reviewing, guiding, and making judgment calls that agents cannot reliably make — architecture decisions, trade-off analysis, and user experience design.

Advanced workflows run agents asynchronously, often overnight:

• Issue-to-PR pipelines — Agent picks up a GitHub issue, implements the fix, runs tests, and opens a pull request
• Multi-agent orchestration — Specialized agents handle different subtasks (frontend, backend, tests) with a coordinator managing conflicts
• Background agents — Cursor and GitHub Copilot support agents that work in the background while developers focus on other tasks
• Overnight runs — Developers assign tasks at end-of-day and review agent output the next morning

Vibe coding describes informal, intuition-driven sessions where developers rapidly build features through natural language conversation with an agent, without rigid specifications. Useful for prototyping and simple features, but professional workflows favor spec-driven approaches for production code to avoid regressions and maintain quality in large codebases.

The Model Context Protocol, donated to the Linux Foundation, standardizes how agents connect to tools and data sources. MCP enables agents to integrate with GitHub, databases, APIs, and other services through a universal protocol, allowing seamless swaps between providers without custom integration code.

• Sandboxed execution — Agents run in devcontainers or Docker to prevent unintended system changes
• Approval gates — Destructive actions (file deletion, deployment, database changes) require human confirmation
• Audit trails — Complete logs of agent reasoning and actions for post-hoc review
• Prompt injection defense — Agents operating on untrusted input must be isolated from sensitive operations

• RedMonk - What Developers Want from Agentic IDEs
• Armin Ronacher - Agentic Coding
• Anthropic - 2026 Agentic Coding Trends Report

• Code Generation Agents — Specific code agent tools and benchmarks
• Agent Safety — Safety practices for code-executing agents
• Agent Debugging — Debugging agent-generated code
• Prompt Engineering — Writing effective prompts for coding agents