Summary: We asked ChatGPT to design a database for digital workers / agentic agents and think outside of the box. We asked Codex to build it. Here is what happened… [Rest is written by ChatGPT]
Press enter or click to view image in full size
> We didn’t let AI “help” us write code.
We let it design a system.
For years, the same argument repeats itself:
> “AI can autocomplete functions, but it can’t design real software.”
Last week, we accidentally falsified that claim.
In roughly 24 hours of vibe coding, a complete system called dwbase was designed, implemented, tested, and integrated — largely by an AI agent (Codex), with ChatGPT being the designer.
And here’s the important part:
dwbase is not a database.
People might keep calling it one. That misunderstanding is exactly why this story matters.
— -
The Misconception: “AI Can Code, But Not Design”
Most criticism of AI-generated software comes from observing the wrong thing.
Yes, AI can:
- Write functions
- Generate boilerplate
- Fix obvious bugs
That’s not impressive.
What skeptics believe AI cannot do is:
Discover the right abstraction
Say “this should not be a database”
Design for future scale, not just present requirements
Coordinate across repos, APIs, runtime constraints, and operational reality
dwbase did all of that.
— -
What dwbase Actually Is (And Why That Matters)
dwbase is a distributed working memory substrate.
It:
- Is append-first
- Is event-native
- Supports gossip and fast indexes
- Integrates with NATS
- Is designed to be embedded as a component, not deployed as infrastructure
- Optimises for retrieval, recall, and evolution, not transactions
A traditional database optimises for:
- ACID guarantees
- Query flexibility
- Schema stability
dwbase explicitly rejects those goals.
And that rejection wasn’t accidental — it was designed.
— -
The Interesting Part: How It Was Built
The system was not created by prompting:
> “Write me a database.”
Instead, the process looked like this:
1. Human sets constraints
- Must be embeddable
- Must work offline
- Must integrate with flows and agents
- Must not require ops-heavy infrastructure
- Must behave well under partial failure
2. AI proposes architecture
- Gossip over NATS
- Append-only log
- Index as acceleration, not truth
- Memory as a first-class runtime concept
3. Human challenges assumptions
“Is this a DB?”
“Where does consistency live?”
“What breaks first at scale?”
4. AI refines
- Removes transactional semantics
- Clarifies ownership boundaries
- Introduces explicit trade-offs
5. Codex implements
- Real Rust code
- Tests
- CLI
- Demo scripts
- Production concerns surfaced early
This wasn’t autocomplete.
This was design dialogue.
— -
The Uncomfortable Truth for Humans
The hard part of software engineering is not typing.
It’s:
- Knowing what not to build
- Naming things correctly
- Drawing boundaries that survive scale
- Designing for evolution instead of perfection
AI is now shockingly good at those things — if the human stops treating it like a junior developer and starts treating it like a design partner.
dwbase exists because we didn’t ask:
> “Can AI write this?”
We asked:
> “What would the cleanest system look like if we removed human ego?”
— -
This Doesn’t Mean Humans Are Obsolete
It means our role is changing.
Humans are still responsible for:
- Setting direction
- Applying judgment
- Understanding context
- Saying no when something feels wrong
But the belief that:
> “AI can’t design serious systems”
is now demonstrably false.
And dwbase — built in a day, designed in conversation, refined through challenge — is proof.
— -
Final Thought
If your definition of “real software” requires:
- Months of meetings
- Massive over-engineering
- Human-only authorship
Then yes — AI didn’t build dwbase.
But if your definition is:
- Correct abstractions
- Honest trade-offs
- Systems that scale conceptually before they scale technically
Then you may need to update your beliefs.
Check out DWBase at: github.com/greentic-ai/greentic-dwbase
P.S. [from the human] a star on Github would be appreciated ;-)