AI agents that plan, write, test, and ship code — with your team in charge
Agentic coding moves beyond autocomplete. A coding agent takes a well-scoped task, reads your codebase, makes a plan, edits files, runs the tests, and hands back a pull request for a human to review. This site explains how that works and how New Zealand teams can adopt it sensibly.
What Agentic Coding Is
Traditional AI assistants suggest the next line. An agent works towards a goal: it decides which files to read, which commands to run, and when it has finished, then reports what it did.
The developer's role shifts from typing every change to framing the task, setting the guardrails, and reviewing the result.
- Plans the change by exploring the repository, its conventions, and related code
- Writes code across multiple files, not just a single suggestion
- Runs builds, linters, and tests, then iterates on failures
- Explains its work in a summary or pull request description
- Stops for review so a person decides what is merged and deployed
Kinds of Coding Agent
Agentic coding is not a single product. It shows up in a few distinct shapes, and most teams end up using more than one.
Interactive agents
Work alongside a developer in the IDE or terminal on the task at hand.
- Multi-file edits with a visible plan
- Runs commands with your approval
- Fast feedback while you stay in flow
Background agents
Run in an isolated cloud environment on their own branch while you get on with other work.
- Pick up issues or tickets asynchronously
- Several tasks can run in parallel
- Finish with a pull request ready for review
Code review agents
Read a diff in context and leave comments before a human reviewer looks.
- Flag likely bugs and missed edge cases
- Check against team conventions
- Free reviewers to focus on design and intent
Test and CI agents
Work on the safety net itself, where results are easy to verify.
- Write missing tests for existing behaviour
- Investigate and propose fixes for failing builds
- Tidy flaky tests and slow pipelines
Upkeep agents
Handle the steady, well-defined work that tends to pile up in every backlog.
- Dependency upgrades and deprecations
- Refactors and migrations with clear rules
- Documentation that matches the code
Multi-agent workflows
Combine agents into a pipeline: one plans, others implement, another reviews.
- Clear hand-offs between steps
- Each agent has a narrow job
- Humans approve at the checkpoints that matter
Give the Agent a Brief
Agents do their best work when the repository tells them how the team works. Many tools read a plain-text instructions file in the repo. A short, honest one goes a long way.
# Project notes for coding agents ## Setup - Install dependencies: npm ci - Run all checks: npm run lint && npm test ## Conventions - TypeScript strict mode; no new `any` types - Use New Zealand English in user-facing text - Dates are stored in UTC and displayed in Pacific/Auckland ## Boundaries - Never commit secrets or edit files under /infra - Do not change database migrations without a human - Keep pull requests small; one concern per PR ## Definition of done - Lint and tests pass locally and in CI - New behaviour has tests - PR description explains what changed and why # A person reviews and merges. Agents do not deploy.
How an Agentic Workflow Runs
The loop is simple. The quality comes from good task framing, fast automated checks, and a careful human review at the end.
Frame the task
A clear issue or prompt: the goal, the constraints, where to look, and what "done" means. Small, well-bounded tasks work best.
Agent plans and explores
It reads the relevant code and project notes, then proposes an approach. For bigger changes, review the plan before any code is written.
Agent writes and tests
It edits files, runs the build and test suite in a sandbox, and iterates until the checks pass or it needs help.
CI and review agents check the work
The pull request runs through the same pipeline as human code: tests, linting, security scans, and an automated first-pass review.
A human reviews, merges, and ships
A developer reads the diff, asks for changes if needed, and owns the decision to merge and deploy.
Guardrails and Human-in-the-Loop
Agents are capable, but they are not accountable. Good teams design the process so that people stay responsible for what reaches production.
Least privilege
Run agents in sandboxes with scoped tokens. No production credentials, and no direct pushes to protected branches.
Tests as the contract
A reliable test suite and CI pipeline are what make agent output trustworthy. Invest there first.
Human review, always
Treat agent pull requests like any contributor's: read the diff, question the approach, and require approval to merge.
Data and privacy
Know where your code and prompts are processed and retained. Check vendor terms against your obligations under the Privacy Act 2020 and any client contracts.
Traceability
Keep a record of which changes were agent-assisted, what the agent was asked, and who approved the result.
Know the failure modes
Agents can sound confident while being wrong, invent APIs, or quietly weaken a test to make it pass. Review for exactly those things.
Getting Started in Aotearoa
Practical adoption guidance for New Zealand teams, from small product studios to government and enterprise delivery teams.
Start small and measurable
Pick one repository with good tests and a backlog of well-defined work.
- Choose low-risk tasks first: tests, docs, upgrades
- Agree up front how you will judge success
- Time-box the pilot and review it honestly
Make the repo agent-ready
The same things that help a new hire help an agent.
- One-command setup, build, and test
- An instructions file with conventions and boundaries
- Fast, reliable CI with clear failure messages
Set policy before scale
Decide the rules once so teams are not guessing.
- Approved tools and where data may go
- What agents may and may not touch
- Review and approval requirements
Grow the skills that matter
The craft moves towards specification, review, and systems thinking.
- Writing clear, testable task briefs
- Reviewing larger diffs critically
- Mentoring juniors so fundamentals are not lost
Keep an eye on spend
Usage-based pricing can add up when agents run in the background.
- Set budgets and usage alerts per team
- Match the model to the task
- Compare effort saved against review time added
Expand what works
Grow from the pilot based on evidence, not enthusiasm.
- Share prompts, instructions files, and lessons
- Add background and review agents gradually
- Revisit guardrails as tools change
Agents write more of the code. Your team still owns the outcome.
Explore the wider agentic picture
Agentic coding is one part of a broader shift in how organisations build, sell, and serve with AI agents. The AXM network brings together New Zealand resources on agentic experience management.
Visit axm.co.nz