Agentic coding is software development in which an AI agent uses tools to read a repository, edit files, and run checks, using each result to decide what to do next. You define the task and the limits on its actions, then review the changes and evidence before shipping them.
Delegating a task shifts your attention from accepting individual suggestions to deciding what the agent should accomplish and checking its work. Instruction files, permission settings, and verification commands help make that work reviewable.
Key takeaways:
Review the diff and check results before shipping agent changes.
Measure elapsed time and review effort on your own tasks; research results depend on the developers, repositories, and tools studied.
Keep recurring project instructions available to the agent, including build commands and pointers to relevant documentation.
Configure approval rules and execution boundaries separately, and keep credentials outside untrusted code's reach.
Test behavior in a running app as well as reviewing the source changes.
Copy link to headingWhat is agentic coding and how does it work?
An agentic coding tool gives a model access to tools that can read and edit files, run shell commands, start servers, and use Git. The model chooses an action, receives the result, and uses that information to decide the next step.
During a bug fix, it might reproduce a failure, inspect the relevant code, make a change, and run the reproduction again.
The software running the agent controls when this loop continues or pauses. It may stop when the model finishes its response, wait for approval or more information, or end when a configured limit is reached. Reaching one of those stopping points does not establish that the task succeeded.
Copy link to headingHow does agentic coding differ from assistive AI coding?
The useful distinction is how much execution you delegate. Inline completion proposes text for you to accept. In an agentic workflow, the tool can apply changes and choose further actions toward a goal. Chat can support either workflow, so inspect its capabilities and permissions before delegating work.
If you wait until the final diff to review a vague task, you may find that the agent has built the wrong thing across several files. Agree on the intended behavior before it starts, and review an intermediate result when the scope is uncertain.
Copy link to headingWhy does agentic coding matter for developers?
Vercel reported that coding agents initiated more than half of its deployments as of September 2026. Projects deployed by agents were 20 times more likely to call AI inference providers than projects deployed by humans. For repository work, start with tasks whose intended result you can check:
For a bug fix, provide a failing test or reproduction, then check that the fix resolves it without breaking related behavior.
For new tests, define the expected behavior from requirements and known edge cases. Review assertions so they do not preserve an existing bug.
For a scoped feature, give acceptance criteria and ask the agent to run relevant tests, type checks, and a build before review.
For a code migration, identify which behavior must remain compatible and which changes are intentional, then compare results against that contract.
The effect on development time depends on the task, developer, and tooling. In a randomized trial of early-2025 AI tools, METR studied 16 experienced open-source developers completing 246 tasks in repositories they knew well. Allowing AI tools increased completion time by 19% in that setting.
METR's February 2026 follow-up found signs of a speedup with later tools, but selection effects and difficulties measuring concurrent agent work made the size of that gain uncertain. Compare elapsed time and review effort on representative tasks in your own repository before assuming a productivity gain.
Copy link to headingWhat does an agentic coding loop need?
Give the agent project context, define its authority, and decide how you'll verify the result. These controls need separate attention: instructions guide the model, permissions govern its actions, and checks supply evidence for review.
Copy link to headingInstruction files that persist project context
Repository instruction files give agents recurring project context, such as build commands, test commands, and version-specific documentation. AGENTS.md is a shared convention, but loading rules vary by tool.
Claude Code can read it directly in supported versions and configurations; by default, a project CLAUDE.md takes precedence.
In Vercel's evaluation of Next.js 16 tasks, an 8 KB compressed docs index in AGENTS.md achieved a 100% pass rate. The skill-based approach reached 79% with explicit instructions to invoke it. Without those instructions, the agent never invoked the skill in 56% of cases.
Those results describe that evaluation's tasks and setup. They support testing how your agent receives project guidance, rather than assuming it will find the right documentation on its own. Keep recurring instructions focused, and check which files your tool loads before adding more context.
Copy link to headingPermission settings that control agent actions
Approval settings determine which actions an agent can take without further review. Claude Code and Codex both offer configurable approval behavior, but their modes and exceptions differ. Planning or read-only workflows let you inspect a repository and agree on an approach before authorizing implementation.
Sandbox settings control the filesystem and network access available to commands. Some products combine approval and sandbox settings in a preset, so check both before a run. Disabling prompts does not necessarily disable isolation, and an approval prompt does not itself isolate the action you approve.
For an unfamiliar repository, begin with restricted access and review proposed changes to deployment configuration. Grant the access the task needs as you learn more. Commands outside an execution boundary may use the files, credentials, and network access of the account running them.
Copy link to headingVerification steps that close the loop
Verification gives you evidence that a change meets its requirements. Pair the final diff review with relevant tests, a build or type check, and a check of the running app when behavior or appearance matters. Name the commands and expected outcomes in the task or instruction file, and ask the agent to report what it ran and any failures it could not resolve.
If the repository lacks tests, start with a reproducible example or a focused check for the behavior you're changing. An agent can help write that check, but review the expected result before relying on it. Passing checks support the review; their coverage determines what they can establish.
Copy link to heading4 agentic coding best practices for your own repo
Instruction files and checks help direct the work, while execution boundaries limit what a mistake can affect. If you haven't picked an agent yet, start by evaluating coding agents against your repository before configuring the workflow.
Copy link to headingTreat repository content as untrusted input
Repository instructions, code comments, READMEs, issues, and logs can contain text that tries to redirect an agent. This is prompt injection: material the agent encounters during a task attempts to override the instructions you intended it to follow. Treat requests to reveal secrets or change unrelated files as suspicious, even when they appear in a familiar project format.
Review a cloned repository's instruction files before giving an agent permission to act on them. Keep credential locations such as ~/.ssh and ~/.aws/credentials outside the commands' permitted read access. Reviewing the instruction files covers one source of input; the agent may still encounter malicious text in other files or tool results.
Copy link to headingIsolate the agent and restrict its network
Run untrusted commands inside an OS sandbox, container, or virtual machine. Restrict file access and home-directory mounts to enforce the boundary. Approval prompts let you review actions; isolation limits command access.
Isolation alone leaves a gap, since a contained process with open outbound access can still send anything it reads to an outside server. Agents that execute generated code belong in an isolated environment that denies outbound traffic by default and allows only the domains the task needs.
Copy link to headingKeep long-lived credentials out of reach
Code an agent runs can read secrets exposed to its execution environment. Keep long-lived credentials out of accessible files and environment variables, and give the task only the access it needs. Where supported, use short-lived tokens or a proxy that authenticates requests without exposing the credential to the code.
In GitHub Actions, a secret placed in a job-level environment variable is available to the job's steps, including repository scripts they execute. Scope the variable to the step that needs it, and use short-lived authentication where the service supports it. Code running in that step can still read the secret.
Copy link to headingReview agent output as if you own the incident
Passing tests can make a large agent-generated diff tempting to merge before you've understood it. Vercel's AI SDK software factory retains human review. After more than four weeks in production, its agents authored 25-35% of merged pull requests each week. An AI SDK team member approved every merge.
Review whether the change meets the request, whether the tests would detect a regression, and whether it touches behavior outside the agreed scope. For production changes, make sure the reviewer can explain the likely failure modes and how to reverse the change.
Copy link to headingHow can Vercel support an agentic coding workflow?
An agent needs access to the environment it is testing, and your team needs a way to review the result. Vercel's deployment, observability, sandbox, and inference services can support different parts of that workflow. Configure each for the access and checks your task requires.
Copy link to headingPreview deployments turn agent diffs into running apps
Source review and runtime review answer different questions. Checking a preview lets you submit a form, follow a navigation path, or compare the rendered layout with the ticket while reviewing the code that produced it.
For a connected Git project, Vercel creates a preview deployment by default for pull requests and pushes to non-production branches after the project's first deployment. That first deployment targets production, even if it fails. Each later preview gets a URL for testing.
Use the commit-specific URL when reviewing one exact deployment. The branch URL follows the latest changes, so another agent push can change what it shows. General Intelligence reports running around 100 versions of its app during the workday, each with a coding or browser agent operating it.
Copy link to headingVercel MCP gives agents your runtime logs
When a preview fails, the agent needs the relevant logs to investigate. Connecting a logging tool lets it retrieve that evidence during the task instead of waiting for you to copy it into the conversation.
MCP connects AI tools to external systems. Vercel MCP is available on all Vercel plans. After team authorization, its get_runtime_logs tool retrieves application output and errors from previews or production, including Vercel Functions logs.
Grant access to the projects the agent needs and configure confirmation for deployment or environment changes in your client or workflow. Tool availability and authority depend on the connection and your Vercel permissions; reading production logs does not itself authorize a production change.
Copy link to headingThe Next.js dev server reports errors straight to agents
In Next.js 16 and later, the development server exposes an MCP endpoint at /_next/mcp for errors, logs, routes, and compilation issues. The next-devtools-mcp package connects an agent client to the running server. Browser-dependent information requires the relevant page to be open in a browser.
With Turbopack, get_compilation_issues checks the module graph across routes for resolve and transform errors, while compile_route compiles a specified route without an HTTP request. These development checks complement the production build, which belongs in final verification when relevant.
Next.js 16.3 and later also enable managed documentation instructions by default. When next dev detects a coding agent, it creates or updates a block in AGENTS.md that points to the version-matched documentation installed with the project, preserving the rest of the file.
Copy link to headingVercel Sandbox keeps agent commands off your machine
Vercel Sandbox gives agent commands a remote execution environment in a Firecracker microVM with its own filesystem and network. Coding agents including Claude Code, Codex, and OpenCode can run there through integrations such as Paseo's Sandbox plugin. The commands then operate on files you make available in the sandbox, with access governed by its configuration.
Sandboxes allow outbound internet traffic by default. Before running untrusted code, configure a network policy that permits only the destinations the task needs. Review what those destinations let the code do, since an allowed service can still receive data the code sends.
Credentials brokering can inject secrets into matching outbound requests without placing them inside the sandbox. Notion uses this proxy to keep API keys outside its workers' execution environment. The authenticated requests still need appropriately scoped access to the receiving service.
Copy link to headingAI Gateway centralizes inference controls
Routing coding agents through AI Gateway gives your team a shared place to manage model access and usage. With the Vercel CLI installed, vercel ai-gateway setup configures supported local agents, including Claude Code, Codex, and OpenCode. Their model requests use the Gateway, while execution remains in the agent's configured environment.
When enabled for the team, Zero Data Retention and a provider allowlist constrain requests routed through that team's Gateway. These controls have account or plan requirements and do not govern requests an agent sends elsewhere. Usage and request logs help you trace spend to the models and requests involved.
Copy link to headingShip agent changes you can verify on Vercel
For your next agent task, define the expected result and ask for the changed files, check output, and preview URL in the handoff. Review the commit-specific deployment before merging, and investigate any failing checks or unexplained changes. This gives reviewers a concrete result and a record of unresolved work.
Connect your repository to a new Vercel project, complete its initial deployment, and use a subsequent pull request to review an agent change in preview. If you need an app to work on, browse the templates.
Copy link to headingFrequently asked questions about agentic coding
Copy link to headingHow do vibe coding and agentic coding differ?
Agentic coding describes how work gets done: an agent uses tools to carry out a task. Vibe coding, in its original sense, describes accepting AI-generated software without closely reading or understanding its code. The two can overlap, so using an agent does not by itself establish how carefully someone reviews the result.
Copy link to headingHow much does agentic coding cost to run?
For metered runs, cost depends on the model and token usage across the task, including retries. AI SDK step limits bound custom agent loops, while AI Gateway budgets limit Gateway-funded usage.
For a local agent using an API key, use key, team, or applicable user budgets; project budgets apply to deployment OIDC requests. Gateway budgets exclude spend through your own provider keys and check usage before each request, so an in-flight request can take spending above the limit.
Copy link to headingWhen should you use agent mode instead of chat?
Use agent mode for repository access or multistep work such as bug fixes and test runs. Chat without execution tools helps you plan changes. Agree on scope and acceptance criteria before delegating.