Stop Prompting, Start Commanding: How Agent Armies Build Better Systems
I had the honor of speaking at the Vibe Coding Finland event on November 25th, hosted at the Helsinki Architecture and Design Museum. The venue alone was worth showing up for, but the topic is something I have been thinking about obsessively: why the way most people use AI for building software is fundamentally limited, and what the next step looks like. My talk title was deliberately provocative – “Stop Prompting. Start Commanding: How Agent Armies Build Better Systems” – because I think the industry needs a wake-up call.
Vibe coding, as a concept, has been a genuine revolution. The idea that you can describe what you want in natural language and get working code back has lowered the barrier to entry for software development in ways we are still processing. But here is the uncomfortable truth: it does not scale. Most people are still throwing vague, conversational prompts at an AI model, getting back something roughly close to what they wanted, and then spending the next hour manually fixing the output. It works for prototypes and small scripts. It falls apart completely when you are building production systems with multiple components, shared state, and real architectural constraints.
The approach I have been developing and refining moves past this artisanal prompting model entirely. The core insight is simple: invest heavily in specifications before you ever touch an AI tool. I mean real specifications – architecture documents, design decisions, task breakdowns with clear acceptance criteria. Not because specifications are fun to write, but because they turn vague intent into precise instructions. And precise instructions are what agents need to do genuinely useful work without constant human intervention.
Once you have solid specifications, something powerful becomes possible: parallel agent deployment. Instead of one developer having one conversation with one AI assistant, you deploy multiple agents simultaneously, each working on a well-defined task within a well-defined architectural boundary. One agent handles the data layer. Another builds the API endpoints. A third works on the frontend components. They are not collaborating in real time – they are executing against shared specifications that ensure their outputs compose correctly. This is not a theoretical framework. I use this approach in production work at Elexive, and it dramatically changes the throughput equation.
The shift I am advocating for is essentially the shift from craft to engineering. Early software development was artisanal too – individual programmers writing code based on informal understanding of requirements. The industry matured by adding structure: version control, CI/CD, testing frameworks, architectural patterns. AI-assisted development is going through the same maturation. Vibe coding is the artisanal phase. Agent armies with structured specifications are the engineering phase. The people who figure this out first will build things the prompt-and-fix crowd simply cannot compete with. That was the message I wanted to leave the audience with, and based on the conversations afterward, I think it landed.
