Method · How I build
I design the system. Then I direct AI to build it.
Code isn't improvised. I define the contracts first —vision, domain, architecture, rules— and only then I build, orchestrating AI under strict rules. Architecture is the absolute priority; code is a consequence.
"No line of code is written until the contract is complete."Rule #1 · Master Contract
The process // 01
From concept to product, in phases.
Each phase ends before the next begins. Content is never produced before the systems capable of supporting it.
-
PHASE 0
Vision and contract
I document what is being built and why. The highest-level contract. Zero code.
-
PHASE 1
Domain and architecture
Entities, invariants, modules and contracts. Structure before behavior.
-
PHASE 2
Rules and data contracts
What is data and what is code. Versioned schemas and fail-fast validation.
-
PHASE 3
Vertical slice
The minimal cut that proves the architecture works, end to end.
-
PHASE 4
Construction
AI implements against the contracts. I review architecture, trade-offs and decisions.
-
PHASE 5
Validation and production
Build, tests, validators and post-work. Only then, to production.
The contracts // 02
Thirteen documents before the first line.
Every project starts with a hierarchy of living documents: when two decisions conflict, the higher-level document wins. This is BabelDestiny's, my game engine in development.
Vision
What is built and why. The highest-level contract.
Domain model
Entities, relationships, states and invariants.
Design
Core loop, mechanics and progression.
Technical architecture
Stack, modules, loaders and contracts.
Data-driven rules
Data vs. code, schemas and validation.
Vertical slice
Scope and acceptance criteria of the first cut.
AI rules
How the AI should work on the project.
Folder structure
What lives —and what does not— in each folder.
Coding standards
Language conventions.
Content pipeline
How each piece of content is created and validated.
Roadmap
Phases 0→6 and advancement criteria.
Decisions
Architecture decision record, each with its rationale.
Orchestrating AI // 03
AI builds. I decide.
I treat AI as a very high-level executor, not an oracle. Every behavior must be explainable; no decision is magic.
Me + reasoning models
- Vision, domain and architecture
- Trade-offs and decisions (recorded as ADR)
- What is data and what is code
- Scope and acceptance criteria
The AI, under rules
- Builds against the existing contracts
- Tier 1 flows; Tier 2 (architecture, schemas) stops and asks
- Mandatory post-work: build, validation, tests
- Documents marked "approval required" are never touched alone
Principles // 04
The rules that aren't up for debate.
- Data over code. Anything that can be data must not be code.
- Explicit over implicit. Zero hidden state.
- Composition over inheritance. Small modules, single responsibility.
- Deterministic execution. Same data, same result.
- Fail fast. Invalid data fails immediately; no silent failures.
- Version every contract. Schemas evolve without breaking.
- Reuse before duplication. A single source of truth.
- Simplicity over cleverness. Maintainable for years.
BabelDestiny
A data-driven engine for an isometric Action Roguelite. Before writing a single line of code, I documented the entire architecture: the full hierarchy of contracts and the rules for AI to build without drifting. The goal isn't a game: it's an engine that grows by adding data, never by touching code.
Let's build systems that last.
For products that need real architecture, not throwaway prototypes.