People talk about AI tools in code a lot, but the actual workflow tends to be underexplained. I want to write about what it genuinely looks like to use AI as a development tool, based on building several projects with it over the past year.
What I mean by AI-assisted development
I'm not talking about using GitHub Copilot to autocomplete a line or two. I mean a workflow where I'm actively working with AI assistants -- Claude, Gemini, ChatGPT -- as part of the development process. Describing what I want to build, asking about approaches, iterating on generated code, debugging with AI assistance.
This is what people are sometimes calling "agentic" development. You're the decision-maker and the director. The AI handles a lot of the implementation. The distinction is important.
Where the human judgment lives
The misconception I want to address is that AI-assisted development means you're just watching code appear. In practice, the human judgment is the hard part:
Problem definition. What problem is worth solving? What should and shouldn't the product do? What are the edge cases? AI can help implement whatever you describe, but it can't decide what's worth building. That's entirely on you.
System design. How should data be structured? Where does state live? How do components talk to each other? What are the right tradeoffs for this specific situation? These are decisions you make before implementation starts, and they determine whether the code that gets generated is actually good.
Review and judgment. Generated code isn't always correct. It solves the stated problem but misses an edge case. It works but uses an approach that will be painful to maintain. It's technically valid but doesn't match what you actually wanted. Knowing which situation you're in requires understanding what you're looking at.
Iteration. The first pass is rarely right. Getting from "working code" to "right code" involves a lot of back and forth, and knowing what's wrong and how to describe the fix clearly is a skill.
What it feels like in practice
The fastest part of development is often implementation of things that are clearly defined. If I've thought through a feature carefully -- what it does, what inputs it takes, what it returns, how it should behave at the edges -- generating working code for that is fast.
The slow part is still the same as it always was: figuring out what you're actually trying to do. Getting the data model right. Understanding why something isn't working. Making judgment calls on competing approaches.
AI tools compress the implementation work significantly. They don't compress the design work.
What I've built this way
Most of the projects on this site were built with AI assistance to varying degrees. KnowThem, Instant Dashboard, The Algorithmic Handshake -- all of these are multi-component systems where I designed the architecture, made the key decisions, and used AI to accelerate the implementation of those decisions.
The results are real, working software that people have used. Whether that's "from scratch" in the traditional sense is a reasonable question, and it's one worth being honest about. The answer is: it's a different way of building, and the relevant question is whether the understanding and the product are both solid. I think they are.
Where this is going
The tools are getting better quickly. The workflow I'm describing now will look conservative in a year or two. The developers who adapt well to this will be the ones who are good at the parts that remain human -- thinking clearly about problems, making good design decisions, reviewing critically, and building things that are actually useful rather than technically impressive.
That's the direction I'm trying to move in.
