The Development Workflow Videos

Lightly edited for clarity.

A lot of developers still think of AI as autocomplete and it’s not. AI isn’t just speeding up code writing it’s reshaping how the entire workflow of software development fits together. If you understand that structure where human judgment lives and where machine acceleration makes sense you can move dramatically faster without losing control of quality.

The classic process hasn’t really changed in decades. You get a feature request you read the requirements you think through architecture design and data models you build it you test it you refactor it you document it and you deploy it.

An AI doesn’t replace that loop. It compresses the time between steps. Instead of spending an hour tracing similar code paths you can ask is there already a controller that handles something similar to this. And you get the answer in seconds. You still own the reasoning you’re just outsourcing the lookup.

When you get a new task don’t start by writing code. Start by asking AI to help you plan the build file structure end points data model UI updates. And the first plan won’t be perfect. You should assume it’s not. Your job is to iterate tighten the logic fix the naming and check the constraints. And once the plan matches your mental model that’s when you start building.

You turn prompting into an architectural conversation and AI shines in the middle of this loop which is debugging and clean up. You can ask why is this variable returning undefined. And have it trace the data path from the UI back to the API or back to the database in seconds.

And once you have the feature working have AI refactor the code. It is brutally efficient at pattern recognition consolidating logic normalizing naming spotting duplicate flows. Context matters. Give it the whole file or the module not just a fragment.

And most developers traditionally have skipped tests because they’re tedious and AI removes that excuse. You can ask it to generate unit tests covering positive and negative test cases and it gets most of the way there on the first pass. And the same goes for documentation summarizing classes and methods for internal docs.

These steps are no longer optional. They’re the guard rails that make hybrid development safe and code bases understandable for the next person or the next model. Think of AI first coding as collaborative engineering not automation. You’re still responsible for system design architectural integrity and judgment calls. AI clears friction so you can spend more time on structure and quality and reasoning. And those are the parts that define great software. AI doesn’t replace developers. It replaces friction.

Lightly edited for clarity.

AI’s made software faster to write but not safer to ship. Teams are finding out the hard way that acceleration without structure just multiplies entropy.

The two things that separate velocity from chaos are the same ones many teams used to skip testing and documentation. AI can produce clean working code in seconds but it can’t hold the system in its head. It doesn’t remember the trade off she made last quarter or the design decisions buried in a team’s thread.

Without documentation every developer human or AI walks into the project blind. Without tests there’s no ground truth. You don’t even necessarily know what correct means.

When AI enters that mix technical debt becomes amplified debt. Every gap in structure gets replicated at machine speed.

And for engineering leaders this isn’t a compliance problem. It is a leverage problem. A well tested well documented code base becomes training data for both people and models. Tests form feedback loops documentation becomes onboarding.

And leadership is not about enforcing this process for its own sake. It’s about scaling clarity as fast as you scale code. Treat tests as specifications not chores. Document intent not just implementation. Pair AI assisted commits with verification automated tests and human review.

This doesn’t slow teams down. It stabilizes acceleration. When teams get this right software quality improves as both teams and models evolve. AI is changing quality but not who owns it we still do.

Lightly edited for clarity.

This weekend I was working on some stuff, and I exceeded my GitHub Copilot token limit.

I was mostly finished, you know, the old way, before AI. And I haven’t forgotten how to code. I haven’t forgotten how to write software. But after spending the last couple of years mostly working with AI every day, it felt really slow.

And it reminded me of something. Writing code is not really the most difficult part of software development, but it traditionally has been the most time-consuming. The hard part’s always been figuring out what to build and exactly how to build it. Understanding the requirements, finding the edge cases, realizing business rules contradict each other, or figuring out that one small change here breaks things elsewhere. And that’s where experienced engineers spend most of their time.

AI has fundamentally changed the economics of software development. Writing code is dramatically faster than it used to be, but it doesn’t eliminate the need for good decisions. And in fact, it does the opposite. The easier it becomes to build something, the more important it becomes to know exactly what should be built.

You can’t hand AI a prompt that says, “Build me a website. It should be cool.” You have to tell it exactly what success looks like.