The Screen Looked Finished. Then I Clicked Save Twice.

AI coding agents write code faster than ever. Here's the six-step workflow I use to turn that speed into software that actually holds up.

Ask an AI coding agent for a product-management page and you'll have one in minutes. A clean form, a couple of buttons, a tidy list of products. It opens in the browser. It looks done.

Now ask it a few ordinary questions.

Does the form reject a negative price? Is the product still there after the server restarts? Can a team member edit something they aren't allowed to manage? And what happens when someone clicks Save twice?

Those questions are the whole gap between generating code and building software. The screen is one visible part. The rest is data that stays saved, rules that hold, access that's enforced, and some way to check that all of it behaves the way you planned.

Here's the good part: closing that gap is a learnable process. And once you have it, AI agents become one of the most enjoyable ways to build that I've found in ten years of doing this.

Where I learned this

I've been building software professionally since 2016, most recently as a freelance .NET and Python engineer.

One project taught me more about this gap than any other. A client needed a business valuation and deal platform: valuation analysis, document drafting, confidential memorandums, controlled sharing, PDF and spreadsheet imports, and print-ready exports. I built it from scratch, from planning and architecture through deployment, and then maintained it for about two years.

The hardest problems never showed up in a demo.

The first was two people working on the same shared document at the same moment. Each save was fine on its own. Together, they could quietly overwrite each other. The second was keeping the app responsive on a modest server when many people used it at once.

Neither was solved by writing code faster. Both were solved by deciding exactly what should happen, writing it down, and then checking that it did. That's the habit I now bring to every AI-assisted build, and it's what makes the speed worth having.

Build with a two-AI team

The setup that works best for me gives each tool a clear job.

• ChatGPT is the planner. It helps clarify the goal, turn an idea into requirements, compare options and write a focused task for the coding agent.
• Claude Code is the builder. It inspects the real repository, proposes a plan based on the actual code, implements approved changes and runs the checks you allow.
• You are the decision-maker. You choose the goal, approve important decisions, review the evidence and decide when something is finished.

The link between them is a handoff: a short, scoped message that asks the coding agent to look before it touches anything. Here's one you can copy today:

Goal:
Allow an authorized business owner to create a digital product.

Before changing files:
1. Inspect the existing product-management flow.
2. Identify the relevant pages, business logic, data model, and tests.
3. Report the current behavior and propose a focused plan.
4. List any assumptions or decisions that need approval.

Do not edit files yet. Do not access production systems or data.

It asks for information and a plan, not code. That one pause lets you catch a misunderstanding while it's still a sentence, not a hundred changed lines.

The six-step loop: Inspect, Plan, Approve, Implement, Verify, Document

Every meaningful change goes through the same loop.

1. Inspect. The agent reads the relevant code and reports what's there today, separating what it observed from what it assumed.
2. Plan. You agree on what the change should do, what it should leave alone, and how you'll know it works.
3. Approve. You read the plan and say yes, in writing, before any file changes.
4. Implement. The agent makes the smallest change that satisfies the plan.
5. Verify. You check the evidence: the actual diff, the test results, the behavior in the browser.
6. Document. You record the decision and save a Git checkpoint.

For a tiny cosmetic edit, some steps can be lighter. Anything touching customer data, permissions, payments or the database gets the full loop.

The Plan step is where most of the value lives, and its core is a few acceptance criteria written before the code. For that product page, they might be:

• An authorized business owner can submit a product name and a valid, non-negative price.
• Invalid information gets a clear message about which fields to fix.
• A successful save shows the new product in the list.
• The product is still there after a page refresh.
• A user without permission can't create a product, even by sending the request directly.

Five plain sentences. They don't dictate a single line of code, yet they tell the agent exactly what done means and tell you exactly what to test.

Four habits that keep a project steady

Build in small slices. List products. Then create a product. Then edit one. Each slice gets its own plan, its own checks and its own Git commit. Small steps are easy to review and easy to undo.

Give the agent a short, true project memory. A concise CLAUDE.md, a README, a note on how data is kept separate between users, and a record of key decisions. The agent reads them every session, so day thirty is as consistent as day one.

Keep production off limits to the agent. It works locally, with synthetic test data and secrets stored outside the code. Payments run in test mode until you're ready.

Check the evidence, not the summary. An agent's "Done! All tests pass" is a claim. The diff, the test output and the page in your browser are the evidence. Read them, and ask "why this way?" when something surprises you. You'll learn a lot just from that question.

The full field guide

Everything above is the opening of a much bigger workflow. I wrote it all down in Building Real Software With AI: A Practical Engineering Field Guide.

Across 40 chapters, you build one complete web application with AI coding agents: a platform where businesses sell digital products like guides, templates and recorded lessons. It starts with a small, working core and grows one verified feature at a time:

• Plan before you build: requirements, scope for every change, choosing a stack, architecture and a project knowledge base
• Set up safely: terminal basics, Git before the first line of code, Claude Code permissions, environments and secrets
• Build the MVP: your first app, database and features, plus testing and debugging
• Add real users and money: accounts, separate business workspaces, roles, orders, Stripe payments in test mode, email and reports
• Make it dependable: security, privacy, performance, integrations, accessibility and release checks
• Deploy and operate: hosting, deployment, day-to-day operation and recovery
• Keep the toolkit: a prompt library, checklists, copy-ready templates, filled-in examples and a glossary

The stack is C#, ASP.NET Core, PostgreSQL, Entity Framework Core, xUnit, Playwright and GitHub Actions. Each chapter explains what the code does and why, so some programming experience in any language is enough to follow along.

It's for developers who can already get code out of AI and want it to hold up, self-taught builders working on a first serious app, and freelancers who want a calmer, more disciplined workflow.

It's $29.

→ Get Building Real Software With AI on Gumroad

And if you'd like to start right now, pick one small feature in your current project and write five acceptance criteria for it before you open the agent. It's a small change that makes everything after it smoother.

I write about software engineering and building with AI here on Medium. You can see more of my work at ayman-atif.vercel.app.