It has been common to hear people say, “I’m not technical. I don’t write code.” A minute later, they describe the automation flows they built in a low-code platform, the legacy workflows they migrated, the syntax that “makes no sense to me,” and the AI assistant they use to build things they have never built before.
They also mentioned catching the AI being wrong. “I’ve been smarter than it a couple times. I’ll take credit for it later.”
They were giving instructions to a machine, checking what came back, and deciding whether to trust it. That’s engineering. They just don’t call it that.
Everyone writes prompts now
Programming languages kept getting more abstract, but the purpose never changed: humans giving instructions to a machine. Write a prompt into a chatbot and you’re using natural language to give instructions to a machine. Same job, different syntax.
When someone tells me they’re not technical, I ask what they typed into the box that morning.
- A project manager who describes herself as “non-technical, I just use it for my PM role” spends her day designing acceptance criteria. That’s specification work.
- A business analyst built a company-approved AI-assisted web app. She’s not a developer, and she’s the strongest adoption story I’ve seen in a while.
- Someone working with ERP config files uses AI to find an invalid character and to explain what a line does inside a giant file. That’s debugging, done in natural language.
None of these people think of themselves as technical. All of them are doing work a technical person used to be the only one who could do.
If we’re writing prompts, which means giving instructions to a machine, we should also find ways to automate the verification of what comes out. Otherwise we’ve moved the work upstream and dropped the safety net.
That’s harder than it sounds, because prompts aren’t deterministic. You can’t assert that the output equals the expected output. You can do what evaluation harnesses do now: check the structure (valid JSON, required fields, length limits, forbidden phrases), compare against gold-standard answers with semantic similarity, or run a second model as a judge against a rubric. The discipline is the same as with code. Define the acceptance criteria before you touch the prompt, and automate the run so an edit can’t cause a silent regression.

The split-by-role instinct
The usual answer when a team of mixed experience feels stretched is to separate people by role. Developers in one room, business analysts in another, quality engineers in a third. I’ve seen it proposed more than once, always with good intentions, and it treats the slowest part of the team as a problem to be contained.
That’s capacity thinking, and capacity isn’t what’s broken.
Capacity and flow are different things
Splitting by role makes each group faster at its own job. That’s capacity. It doesn’t make the work move, because these people are one team, and their work moves through handoffs.
Say business analysts produce ten stories per sprint. AI lets the developers implement those ten stories in two days instead of two weeks. Implementation isn’t the bottleneck here. It’s an over-capacitated step in the middle of the stream, and a step with spare capacity does two things when it runs ahead of the system’s pace. It drains its input buffer, so the developers sit idle while the analysts scramble to feed them. And it overproduces into its output buffer, so the quality engineers inherit a flood they can’t absorb at that rate. The team got faster in one place and broke at both edges.
WIP is the number to watch. When implementation outruns review, work in progress climbs, and once WIP climbs, lead time follows. That’s Little’s Law doing what it always does. You get more work sitting between stages and less work finished.

This is the old waterfall picture wearing new clothes. Coders in one room, testers in another, business people in a third, and nobody watching the seams between them. The seams are where the work flows or stalls. Train each role in isolation and no one looks at the handoffs, which is where the real constraint lives.
Give the surplus capacity away
The instinct is to protect the people who fall behind. Put them in a place where the pace matches theirs, let them watch the technical folks do the hard parts.
That’s the wrong move, and they already know it. I’ve seen teams ask for more time at the keyboard rather than more explanation. Watching and driving are different needs, and asking for the keyboard is the tell. They don’t want to be the audience. They want to do the work.
I’ve also seen someone running behind while still driving the work in front of them. Running behind isn’t the same as being incapable. Measure against the fastest hands in the group and what looks like a skill gap is a speed measurement.
So the move that runs against instinct: take some of the surplus capacity off the developers’ keyboard output and put it into the rest of the pipeline. Pairing with the analysts on the spec, writing the evaluation harness with the quality engineers, showing someone what a good prompt looks like and why the output is wrong. Their line rate drops. The system’s lead time improves, because WIP stops piling up at the handoffs.
Not that developers are automatically the best at this. Plenty of them are poor at articulating intent. The people writing prompts all day may be far better at it, and with AI at their side they can produce more output than the developers do. That’s the point of moving the team through the stream together.

One team, moving through the stream together, with a check at each stage. The discovery side is where defects do the most compounding damage. When AI makes implementation nearly instant, a vague acceptance criterion or a wrong assumption turns into working code at machine speed. Defining intent and bounds stops being pre-work and becomes the highest-leverage control in the stream.
Get the discovery wrong and the engineers build the wrong thing faster. A plane moving really fast in the wrong direction burns a lot of expensive fuel.
What nobody has answered yet
Slowing down buys time to answer the questions that decide whether any of this holds up.
- Are the stakeholders ready to receive the volume of work a faster team produces?
- Does the team’s cadence account for AI-accelerated work, or is it still built around the old handoff speeds?
Until those are answered, going faster moves the bottleneck and calls it progress.
Splitting people by role fixes the discomfort of a mixed room by giving up the one thing that makes the room valuable.
I’ve stopped thinking about how to make each role go faster. The question I ask now is where the work stops moving, and who needs to be in the room when it does.





Leave a Reply