For years, a significant portion of software development revolved around a recurring sequence: first you thought, then you documented, then you built. Artificial Intelligence came along and disrupted that sequence – far from gently.
In that context, the Campfire Model emerged, an idea articulated by Steve Yegge in 2026 as a response to the rise of Spec-Driven Development. Its core point is interesting, provocative, and simple at the same time: the true center of development should no longer be a static specification, but a living prototype that evolves with the team in ultra-short cycles, with full transparency and without endless handoffs between areas.
The campfire metaphor works because it captures a very real feeling: everyone works around the same thing, sees the same thing, fixes, tests, and pushes the product forward.
Software stops progressing as a chain of documents and starts evolving in a different way-more tangible, more organic.
If you read what’s being written about the topic, it all sounds new. But those of us who’ve been around for a while know it’s not entirely new.
Old trick, new dog
Anyone who has been close to GeneXus over the last 40 years knows that rapid prototyping and iteration over a functional prototype-created quickly with AI-have always been part of GeneXus’s DNA.
Even though it was deterministic AI, not the generative AI that’s currently in vogue, the core concept is the same: technical and non-technical people working together around a functional prototype, evolving it step by step into a final, enterprise-grade, mission-critical system.
GeneXus was born on that idea: model, generate, test, iterate, and regenerate- something that runs counter to heavy, linear development overly tied to documentation. And this philosophy is not an exception, but a natural way of building software.
In the GeneXus methodology, this is explicitly described as an incremental cycle: define objects in the Knowledge Base, generate code, test against the real system, iterate, and regenerate – evolving the solution from something simple into something more complete with each pass.
For GeneXus, the prototype was never just a mockup to show in a meeting. It has always been a serious way to discover the right system by building it early, seeing it work, and evolving it on a real foundation.
In GeneXus, the prototype was never at odds with rigor
This is an important difference – and probably the most relevant one in this conversation.
The Campfire Model is right to focus on the living prototype. But in the enterprise world, it’s not enough to move fast with AI. You also need to be able to maintain, govern, integrate, and evolve what you build – securely – over years or decades.
That’s where GeneXus makes a contribution that no other approach replicates today. The functional prototype doesn’t get trapped in permanent improvisation. It is supported by a Knowledge Base – a model that captures business logic independently of technology – and by a deterministic generation engine that produces correct-by-construction code. This means that initial speed does not turn into structural fragility. What gets prototyped is semantically validated, normalized, and generated with the same guarantees as production software.
It’s about being able to explore, create, and evolve quickly without losing the knowledge that makes the system valuable.
Why the Campfire Model resonates so strongly with GeneXus
When Martin Fowler argues that LLMs don’t change the value of building and releasing small chunks of functionality, but instead promise to increase the frequency of that cycle, he’s describing something very close to GeneXus’s historical logic: shortening the path between intention, execution, and validation.
The difference is that today this dynamic becomes even more powerful.
With GeneXus Next, the conversation no longer ends at generating systems, APIs, or business logic. The platform incorporated Nexa, an agentic software architect specialized in GeneXus, which allows applications, flows, and components to be defined through natural language interactions. It is the bridge between what is needed and software components that can begin to take shape – without writing a single line of code manually.
This amplifies the GeneXus tradition and keeps it at the forefront of new software development trends, especially when combined with the agentic paradigm.
From functional prototype to agentic software
This is where the next stage comes in.
If GeneXus has historically enabled fast iteration over functional software, its natural evolution is to do the same with AI Agents that now actively participate – by default – in the software development process within companies.
That’s exactly what GeneXus for Agents does, publicly launched on April 1, 2026: a set of skills, tools, and interfaces that allows AI Agents – such as Claude Code, Globant CODA, or OpenAI Codex – to operate directly on GeneXus Knowledge Bases.
Agents can read objects, propose changes, generate auxiliary code, and explore the existing system, all through a standard protocol (MCP). GeneXus validates every change using the same deterministic engine as always: normalization, impact analysis, and business rules. Agents propose; GeneXus validates and generates.
All of this stands on top of Globant Enterprise AI’s governance layer for Models, Agents, and Corporate Data, which gives GeneXus a real competitive advantage in today’s market.
The result is that the campfire of the Campfire Model is no longer made up of just people. Now there are also development agents around the prototype – contributing, proposing, and accelerating – while a governing engine ensures that what is built remains manageable, maintainable, and correct by construction.
The future is not spec-first or prompt-first – it’s prototype-first
The most valuable software development doesn’t seem to be heading toward static documents, nor toward improvisation without memory. It’s moving toward environments where you can test quickly, iterate on something real, capture durable knowledge, and bring it to production with governance.
Different platforms will have different mechanisms. GeneXus has the Knowledge Base and a new text-based representation of it, making it easier for agents to understand.
This aligns with what the Campfire Model clearly identified: iteration is the heart of the process, the functional prototype leads the way, and AI helps us bring that prototype to production faster.
And it’s what GeneXus has been doing for more than 35 years – though now with a new vocabulary: agents, flows, skills, MCP, generative AI, symbolic AI, orchestration.
What has changed is who can sit around the campfire. Now there are agents, language models, open protocols, marketers, designers, and finance professionals – alongside developers. But the idea of building around a living, functional, evolving core is nothing new for GeneXus.
The history of software doesn’t repeat itself, but it rhymes. And these echoes from the past are the clearest sign that we are building the future on the right foundations.
You may also be interested in reading:
26 deep dives on AI applied to businesses
How and Why to Use Generative Artificial Intelligence in Companies
Creation and In novation in the Age of AI
Low-Code + Generative AI: Challenges and Opportunities for CIOs