AI for engineering and IT
AI-native engineering: how IT and software teams build with agents
AI-native engineering means agents write, test, review and document code, and engineers set the direction and make the calls. Native helps IT and software teams make that shift on their own codebases, starting with one workflow in production within weeks. It is also how Native builds every system it delivers.
Featuring insights fromShaun Devan · Founder & CEOUpdated · 3 min read
Where AI has an impact in engineering and IT
AI code review
Every pull request reviewed by an agent first, with findings written up for the engineer.
Spec to pull request
Small changes and fixes drafted from a ticket as a reviewable pull request.
Test generation
Tests written and maintained alongside the code they cover.
Legacy migration
Old systems read, mapped and moved piece by piece, with behaviour proven unchanged.
Internal tools
Admin screens, reports and workflows built in days.
Documentation
Docs and runbooks kept current with every change.
Incident triage
Alerts read, likely causes found and the right person paged with the context attached.
IT service desk
Access requests and common issues handled end to end, with approvals where they belong.
What changes in an AI-native engineering team
Coding assistants in an editor are where most teams stop. An AI-native team goes further: agents take a written spec to a draft pull request, review every change before a person does, write the tests, keep the documentation current and work the backlog of small fixes nobody gets to.
Engineers spend more of their time on design, review and the decisions that need context, and less on typing. The same team ships more, and the code it ships is better tested.
| Work | Agents | Engineers |
|---|---|---|
| Small fixes and modifications | Draft the change as a pull request | Review and merge |
| Code review | Review every pull request first, with findings written up | Make the call |
| Tests | Write and maintain them alongside the code | Set what must be covered |
| Documentation | Kept current with every change | Approve |
| Architecture and design | Draft options and trade-offs | Decide |
Where to start
- AI code review on every pull request. Fast to set up, immediately useful, and it teaches the team how agents reason about their code.
- A bug and small-change queue worked by agents. Requests from the business arrive as tickets and leave as draft pull requests for an engineer to review.
- Legacy migration. Agents read old code, map what it does, and move it piece by piece with tests that prove behaviour is unchanged.
- Internal tools. The admin screens and reports every business needs, built in days rather than queued for months.
Guardrails that keep quality up
Agents never merge their own work. Every change is a draft until a person approves it, branch protection stays on, and test runs gate every release. Secrets stay out of prompts, and agents get the narrowest access each task needs.
The aim is more output at the same or better quality, so the measures are review findings, escaped defects and lead time, not lines of code.
What an engagement looks like
We start with your delivery process as it runs today: where work waits, what gets reviewed, how releases go out. The first workflow, usually AI review or the small-change queue, is live within weeks. Within months the team works with agents across the whole cycle, and the practices are written down so new engineers adopt them from day one.
How to measure it
- Lead time from ticket to production
- Share of pull requests opened by agents and merged after review
- Review findings caught before a person reviews
- Escaped defects per release
- Backlog of small changes, week over week
Case study · A mid-market software company
A mid-market software company moved its engineering team to an AI-native workflow.
Native helped a software company's engineering team put agents on code review and its backlog of small changes. Every pull request now gets an AI review first, and most small fixes arrive as draft pull requests for an engineer to approve.
The challenge
A small team was split between roadmap work and a growing queue of small requests from the business. Reviews were the bottleneck, and minor fixes waited weeks.What we built
- AI review on every pull request, with findings posted for the author before a teammate looks.
- An agent that turns small-change tickets into draft pull requests with tests, for an engineer to review and merge.
- Written practices for working with agents, so new engineers adopt them from their first day.
The result
The backlog of small changes cleared, reviews stopped holding up releases, and the team spent its time on the roadmap.Frequently asked questions
What is AI-native engineering?
It is a way of building software where agents write, test, review and document code, and engineers set direction, review the work and make the decisions. It goes beyond coding assistants in an editor to agents across the whole delivery cycle.
Will AI agents merge code on their own?
No. Agents open draft pull requests; a person reviews and merges. Branch protection and test gates stay in place.
Where should an engineering team start with AI?
AI code review on every pull request, or a queue of small changes worked by agents. Both are quick to set up and show their impact within weeks.
Can AI help with legacy systems?
Yes. Agents read old code, map what it does, and help migrate it piece by piece, with tests proving the behaviour is unchanged.
How do you measure AI's impact on engineering?
Lead time, the share of changes drafted by agents and merged, review findings caught early, and escaped defects. Not lines of code.