How we turn an idea into an iconic product.
Four patterns, working together. None of them are new. The discipline of using them together, on every product we build, is.
Four patterns. One way to ship.
Most teams pick one pattern, ignore the others, and wonder why the product feels brittle. We use four — deliberately combined — because each solves a problem the others cannot. This is the machinery behind every Leanicon product.
- Domain-Driven Design — keeps the product honest to the business.
- SOLID — keeps the code honest to itself.
- Spec-Driven Development — settles what to build before code exists.
- Agentic Programming — keeps humans doing the work only humans should do.
Build around the language of the business.
AI products fail in two ways: they ship the wrong thing fast, or they ship the right thing in a way that can't evolve. DDD prevents both. By modelling the domain explicitly — entities, bounded contexts, ubiquitous language — the product stays legible to product, to engineering, and to the agents we build into the workflow.
- Every product starts with a domain map, not a database schema.
- Bounded contexts are first-class. One service never becomes the dumping ground.
- Ubiquitous language lives in code, specs, and agent context.
- Avoids: Anemic models. Tangled services. Products nobody can explain.
Five rules for code that survives the second feature.
AI products iterate faster than traditional ones — models change, prompts evolve, integrations multiply. SOLID is the difference between a codebase that bends and one that breaks. It's also the foundation that makes agentic programming safe.
- Single Responsibility — every module does one thing.
- Open/Closed — extend through composition, not rewrites.
- Liskov Substitution — interfaces mean what they say.
- Interface Segregation — small, purpose-built contracts.
- Dependency Inversion — high-level logic never depends on details.
- Avoids: The rewrite. The all-hands refactor. The six-things-break conversation.
The spec is the source of truth.
The biggest cost in software isn't writing code — it's writing the wrong code. Spec-Driven Development separates the two things that should never be confused: deciding what to build, and deciding how to build it. When the spec is rigorous, engineering moves fast. When it isn't, no methodology can save you.
- Specs are written in language the business can validate.
- Specs are reviewed before any engineering work starts. No exceptions.
- Specs define behaviour and acceptance criteria — not implementation.
- Drift is caught at review, not at launch.
- Avoids: 'I thought you meant…' The half-built feature nobody signs off on.
Developer as architect and reviewer. Agent as implementer.
The economics of building software have changed. Treating a senior developer as a typist is now indefensible. Agentic programming reframes the role: developers design systems and review outcomes, agents do the implementation work, supervised. Velocity goes up. Quality goes up — if the rest of the methodology is in place.
- Developers operate as architects and reviewers, not implementers.
- Agents work against the spec, grounded in the domain model.
- Every change is reviewed by a human before it ships. Always.
- Agents handle: scaffolding, tests, refactors, glue code.
- Avoids: Burning senior engineers on work an agent can do. Shipping code nobody understands.
Four patterns. One loop.
The patterns aren't a menu. They're a system. Each one makes the next one work. Pull one out and the rest weaken.
DDD gives the spec something honest to describe.
Without a real domain model, specs describe implementation details instead of business behaviour. The spec becomes a technical document nobody in the business can validate.
Spec-Driven Development gives the agent something unambiguous to build.
An agent with a vague spec improvises. An agent with a rigorous spec produces reviewable, consistent output. The spec is the agent's contract.
SOLID keeps what the agent builds easy to review and easy to change.
Agent-generated code reviewed against SOLID constraints produces a codebase humans can navigate and update. Without SOLID, velocity gains become technical debt.
Agentic Programming is what makes the whole loop fast enough to matter.
DDD, specs, and SOLID create the conditions for safe agentic programming. Agentic programming is what makes the methodology's speed advantage real at the delivery layer.
The stack every Leanicon product starts from.
We never start a product from an empty repository. Three internal assets carry from the last build into the next one — which is why a first release takes weeks. They are not for sale. They are why we can make the promise.
UI Library
A component library built for AI products and the marketing surfaces around them. Every product inherits a coherent interface on day one instead of designing one from scratch.
SaaS Modules
Auth, organisations, billing, multi-tenancy, notifications, model routing. The plumbing every product needs and no product is ever remembered for.
Agent Knowledge Base
Our methodology encoded as context for the agents doing implementation. It is how four patterns stay consistent across four codebases.
Want this applied to your idea?
The methodology is not a course. It is how we build, and it comes with every build.
