The idea
Most “how to do this” knowledge lives in static documents — a recipe, a project writeup, a set of instructions — that can’t be reused, remixed, or connected to anything else. I wanted to see what it would look like if that knowledge were structured instead: broken into reusable pieces that could be composed into new plans instead of copy-pasted.
What it does
A Brick is one meaningful accomplishment. A Blueprint composes Bricks — and other Blueprints — into a way of reaching a larger outcome. Publishing a Blueprint freezes it as an immutable version, and a Build is one real execution of that version. What a Build records is what improves the next version of the Blueprint.
Physical or digital objects needed along the way are first-class Things — tools, materials, resources — and an Ingredient is the contextual link between a Thing and the Blueprint that uses it (not a separate object of its own). The same Thing can show up across many Blueprints, with different quantities or context each time.
A Blueprint for framing a stud wall, for example, could be built from Bricks for planning, framing, and installation — each of those Bricks referencing Things like lumber, fasteners, and tools.
How it works
Bricks is a Next.js app backed by PostgreSQL via Drizzle ORM, with Tailwind for styling and Vitest for the test suite. The whole thing runs in Docker for local Postgres, with migrations, seed data, and a db:reset command that gets you to a populated dev instance from nothing. CI runs typecheck, lint, build, and the full suite against a real Postgres instance on every push and PR.
The app’s shape follows the core concepts directly: a discovery homepage, /work/[id] for viewing any Brick or Blueprint (list, graph, or sequence view), /things for the pool of reusable Things, and /builds for tracking real executions.
AI-assisted creation is part of the vision — generating editable sub-Bricks from an existing Brick to help turn a rough idea into an actionable plan, producing structured, human-editable output rather than an opaque AI-written document.
Interesting challenges
The core architectural question is how to represent knowledge as interconnected, reusable objects rather than isolated documents — Bricks and Blueprints have to compose cleanly (a Blueprint referencing other Blueprints), Things have to stay independent of any single Blueprint that uses them, and published versions need to stay immutable while still allowing a Blueprint to evolve going forward.
Progress and outcomes
The prototype has working data models for Bricks, Blueprints, Things, and Builds, a seeded local dev environment, and CI running the full suite against Postgres. It’s still a prototype — the broader product vision (AI-assisted Blueprint generation, affiliate-linked Things, creator monetization) is ahead of what’s implemented today.
What comes next
Progressive elaboration via AI (turning a single Brick into editable sub-Bricks) and the creator-economy angle — Blueprints built around purchasable Things, with affiliate revenue for the creator — are both concept-stage rather than built.