Agentic Coding

Agentic coding is the practice of using AI agents to write, test, debug, and maintain code with significant autonomy. Unlike AI code completion (where AI suggests the next few lines) or AI chat about code (where AI answers coding questions), agentic coding involves the AI planning and executing multi-step development tasks — reading files, writing code, running tests, fixing errors, and iterating until the work is complete.

From autocomplete to agent

The evolution of AI in software development has moved through distinct phases:

1. Autocomplete (2021+): AI suggests completions as you type. GitHub Copilot pioneered this — finishing lines, suggesting functions, filling in boilerplate. Useful but limited to line-level suggestions.

1. Chat assistant (2022+): AI answers coding questions, explains code, and generates code snippets in response to natural language prompts. More capable but still requires you to integrate the output manually.

1. Agentic coding (2024+): AI operates as a development agent — it reads your codebase, understands the context, plans a series of changes, implements them across multiple files, runs tests, and fixes issues. You describe what you want; the agent builds it.

How agentic coding works

An agentic coding tool typically:

1. Understands context: Reads relevant files, configuration, documentation, and coding standards (e.g., through a CLAUDE.md file)
2. Plans the approach: Breaks the task into steps — which files to modify, what logic to implement, what tests to write
3. Implements changes: Writes code across multiple files, following your project's patterns and conventions
4. Validates: Runs existing tests, linters, and type checkers to ensure the changes work
5. Iterates: If tests fail or errors occur, the agent diagnoses the issue and fixes it
6. Reports: Provides a summary of what was done and why

Claude Code as an agentic coding tool

Claude Code is Anthropic's agentic coding tool. It operates in your terminal and can:

• Read and understand your entire codebase
• Plan and execute multi-file changes
• Run shell commands, tests, and builds
• Fix errors and iterate until tests pass
• Follow project-specific instructions via CLAUDE.md
• Connect to external tools through MCP

What agentic coding is good at

• Feature implementation: "Add user authentication to the application" — the agent plans the schema, writes the routes, creates the UI, and adds tests
• Bug fixing: "Users report that checkout fails on mobile" — the agent investigates, identifies the issue, and implements a fix
• Refactoring: "Migrate this codebase from JavaScript to TypeScript" — the agent systematically converts files and fixes type errors
• Testing: "Add comprehensive unit tests for the payment module" — the agent writes tests that cover edge cases
• Documentation: "Generate API documentation from the codebase" — the agent reads the code and produces accurate docs

Agentic coding limitations

Agentic coding is powerful but not infallible:

• Complex architecture decisions: Agents work best within established patterns. Novel architectural choices still require human judgment.
• Business logic: The agent does not understand your business requirements deeply — clear specifications matter.
• Security-critical code: AI-generated code should be reviewed for security implications, especially for authentication, authorisation, and data handling.
• Quality varies: Output quality depends on the clarity of instructions and the quality of the existing codebase.

The human role in agentic coding

Agentic coding does not eliminate the developer. It changes the developer's role:

• From writing code to specifying intent: You describe what to build, not how
• From implementation to review: You review and approve changes rather than writing every line
• From debugging to oversight: You verify that the agent's solutions are correct and appropriate
• From routine to strategic: You focus on architecture, design, and complex decisions while the agent handles implementation