Manifesto

Plan first Code later

ARCHITECT

Plan before action.

Take back control of your ideas.

Use Architect See how it works Field notes

Method

Before the writes code

Structure first. Code second.

What the system must do.

Architect turns vague ideas into clear requirements before the agent writes a single line of code.

Users can book a room.
The system supports 1000 concurrent users.
Payments are out of scope for v1.

Why we build it this way.

Architect captures the key technical decisions as ADRs - Architecture Decision Records - so every important choice, reason, and trade-off is explicit.

Use PostgreSQL because search matters.
Keep a monolith because the team is small.
Use stateless JWT instead of server sessions.

How the parts talk to each other.

Architect defines the boundaries between modules so the agent knows what can call what, what to expect, and what to leave alone.

Auth exposes verifyCredentials(email, password) -> User.
Booking calls Payment.charge(amount) -> transactionId.
Notifications listen to OrderPlaced events.

Product

What Architect gives you

Structure before implementation. Visibility before trust.

Requirements before implementation

Architect interviews the idea until the vague parts are gone. Scope, constraints, and out-of-scope decisions become explicit before the agent starts moving.

Architecture decisions with trade-offs

Every important technical choice gets a reason. The product does not just suggest tools - it captures why they fit, and what they cost.

Contracts between moving parts

Modules stop being hand-wavy boxes. Architect defines who can call what, what comes back, and where the boundaries are supposed to hold.

A visual map before code takes over

Instead of trusting a terminal transcript, you see the project as a structure: connected, reviewable, and easier to change without guesswork.

Field notes

From the build log

Release notes, architecture decisions, and product thinking from the Architect build.

Architect Apr 14, 2026

Architect v0.3: tightening the discipline loop

The latest release makes the planning loop stricter, clearer, and much harder to skip when the urge to vibe-code kicks in.

6 min read Architect, Release, Product

Architecture Apr 8, 2026

Why Architect stays desktop-first

Keeping the product local changes the trust model, the UX, and the kind of features worth building.

5 min read Architecture, Desktop, Agents

SQLite Mar 31, 2026

SQLite as the memory layer for a local tool

A small local database is often enough for the kind of continuity an AI-assisted desktop app actually needs.

7 min read SQLite, Storage, Local-first

Writing Mar 21, 2026

Writing the build log while the product is still messy

Documenting a product before it feels finished is uncomfortable, but the notes are more valuable when the edges are still visible.

4 min read Writing, Process, Product

Browse all notes