AI Software Engineering: A Practical Guide

AI software engineering is building software with AI in every stage of the work: planning, coding, testing, review and maintenance. Agents draft the code; engineers decide and review. The engineer’s job moves from typing every line to setting the goal, checking the output and owning the result.

How AI is changing software engineering

For decades every line was written, tested and debugged by hand. That works, but it is slow, and much of the time goes to boilerplate and routine changes.

Coding agents such as Claude Code, OpenAI Codex, Cursor’s agent and GitHub Copilot now take a task, edit files across the repository, run the tests and open a pull request. The engineer still makes the design decisions and reviews every change. What changes is where the hours go: less time writing boilerplate, tests and simple refactors, more time on design and review. Our guide to AI coding agents covers how they work and how teams run them.

The engineer’s new responsibilities

• Prompting: describing a task clearly enough that an agent gets it right the first time.
• Validating output: reviewing AI-written code for correctness, security and performance before it merges.
• System design: deciding how the pieces fit, including which parts use AI models at runtime.
• Hard problems: the ambiguous, cross-cutting work that agents still handle badly.

The three parts of an AI-assisted workflow

An AI-assisted workflow rests on three practices: writing clear instructions for AI, integrating models into your product, and using AI to test what you build.

Prompt engineering

Prompt engineering is the skill of telling a model exactly what you need. “Make a user login” gets you generic code. “Create a Flask endpoint that accepts JSON with email and password, validates both, and returns a JWT on success” gets you something close to usable.

Give the model the context it can’t guess: the existing code, the libraries you use, your constraints. Our guide to prompt engineering best practices goes into detail.

Model integration

Integration means calling an LLM API from your application to build a feature on top of a model. It involves trade-offs:

• Performance vs. cost: larger models are often slower and cost more per call. Pick the smallest model that does the job well.
• Specialized vs. general: a model fine-tuned for one task can beat a general model on that task, at lower cost.
• Security and privacy: decide what user data may reach the model, and check the provider’s data terms.

AI-assisted testing

AI tools can generate tests, propose edge cases and point at risky changes:

• Generate unit tests that cover the paths through a function.
• Find edge cases such as empty input, nulls and unusual values.
• Flag risky changes in new code before review.

Generated tests still need review: a test that asserts nothing useful gives false confidence.

AI across the software development lifecycle

Stage	Traditional approach	With AI
Requirements	Manual write-ups and analysis	AI drafts user stories and spots gaps
Design	Whiteboards and hand-drawn diagrams	AI suggests architectures and drafts diagrams
Coding	Every line by hand	Agents write and edit code; engineers review
Testing	Hand-written test cases	AI-generated tests and edge cases
Deployment	Hand-written pipeline configuration	AI drafts and debugs pipeline configuration
Maintenance	Manual refactoring and bug fixing	Agents propose refactors and fixes from failing tests

The AI engineering toolkit

The toolkit has three layers: coding tools in the editor and terminal, platforms for managing models, and testing tools.

Coding assistants and agents

These live in your editor or terminal. GitHub Copilot offers inline suggestions, chat and an agent mode inside VS Code and other editors. Cursor is an AI-first editor with its own agent. Claude Code and OpenAI Codex are agents that run in the terminal, in editor extensions and in the cloud. For a comparison, see our guide to the best AI coding tools.

They take over the predictable parts of coding, such as boilerplate, tests and routine refactors, so engineers can spend their time on design and hard problems.

MLOps platforms

If your product runs its own models, you need to deploy, monitor and update them. That is MLOps (machine learning operations):

• Hugging Face hosts pre-trained models, datasets and tools, so you can try models without training your own.
• Weights & Biases tracks experiments and model versions, so a team can see how models perform and reproduce good results.

AI testing tools

Some testing tools use AI directly. Diffblue Cover writes unit tests for Java code. Applitools uses visual AI to spot UI bugs in screenshots.

Measuring the impact

Lines of code and story points say little once AI writes much of the code. Measure what ships and what it costs to keep:

• Time to merge: how long a pull request with AI-written code takes from opened to merged. On our own team, the median agent-written pull request merged in 37 minutes, across 866 merged pull requests in two repositories. That is one small team, not a benchmark: see what 866 agent-written pull requests show.
• Code churn: how much code is rewritten or deleted soon after it merges. High churn on AI-written code means the output is missing the mark.
• Delivery rate: how quickly features go from idea to production.

Our guide to developer productivity metrics covers more of what to track.

Getting a team to adopt AI

Adoption is more a people problem than a tool problem. Start with a small pilot: one project and a few engineers who want to try the tools. Their results become your internal case study.

Then teach the skills hands-on:

• Prompting: how to give an agent context, constraints and a clear task.
• Validating AI code: how to review, test and debug what an agent writes. The engineer stays responsible for quality and security.
• Tool-specific practice: sessions on the tools you use, such as GitHub Copilot or Cursor, where people share the shortcuts and workflows that work.

A rollout checklist

1. Explain why. Say plainly what the tools are for: less tedious work and faster delivery.
2. Train more than once. Combine workshops, short videos and pairing sessions.
3. Set guardrails. Agree on rules for security, secrets and IP before anyone starts.
4. Collect feedback. Give people a channel to report what works and what doesn’t, and adjust.

Where it is heading

Agents that take whole tasks

Agents that take a whole task are already here. GitHub Copilot’s cloud agent takes an issue and works on a branch; Codex Cloud, Claude Code on the web and Cursor’s Cloud Agents run tasks while you do something else. As they improve, engineers spend less time writing code and more time specifying work, reviewing it and deciding what ships.

Specialized models working together

One task may soon involve several models, each doing what it is best at:

• A code model writes the business logic.
• A security model looks for vulnerabilities.
• A design model drafts the front-end components.
• A documentation model writes the guides.

The engineer’s skill becomes knowing which to use for what, and fitting their output together.

Frequently asked questions

Will AI replace software engineers?

No. AI handles routine work well: boilerplate, basic tests, simple refactors. Engineers still design systems, work through ambiguous problems and review every change. The job shifts from writing every line to directing and checking AI’s work.

What are the biggest risks of using AI in development?

Code quality, security and intellectual property. AI-written code can look right and still hide bugs or vulnerabilities, and it can reproduce licensed code. Review every AI-written change, run security scanners before merging, and set clear rules for what code and data may go into AI tools.

How can I start learning AI software engineering skills?

Use an AI coding tool such as GitHub Copilot, Cursor or Claude Code on real tasks: generating tests, refactoring a function, explaining unfamiliar code. Practice writing specific prompts. Then build a small app that calls a model API from OpenAI, Anthropic or Google to learn integration.

---

Zest records each engineer’s coding-agent sessions (Claude Code, Codex, Cursor, Copilot Chat) and links them to the pull requests they led to.