Architect

System design and planning patterns for architecture decisions, PRDs, specifications, and…

A system-design and technical-planning toolkit that takes a feature from fuzzy requirements to a concrete, defensible architecture. It guides requirements gathering, data and API design, scalability decisions, and production readiness: and forces every significant choice through structured tools like C4 modeling, ADRs, blast-radius analysis, and second-order effect thinking.

$15 one-time
Add to a kit →

Prices include 20% VAT. · Forged on real agency work · one-time, no lock-in

  • Type Skill
  • Category Development
  • Delivery Email · instant
  • License One-time
Run preview
forgehouse, architect

Inside the run · no black box

See the actual work before you buy it.

A vague feature idea leaves this skill as a buildable spec with its trade-offs on record. The planning loop runs through six fixed stations:

  1. Requirements gathering answers a fixed question set before anything else: what problem this solves, who the users are, what the success metrics are, what the constraints and non-functional requirements look like.
  2. Technical design fills the spec template section by section: data model with schema, API contract table per endpoint, UI component list, integration points, security considerations and performance targets.
  3. Every versus-decision (monolith vs microservices, REST vs GraphQL vs tRPC, PostgreSQL vs MongoDB vs Redis) gets resolved against the built-in decision matrices and recorded as an ADR with status, alternatives considered and consequences.
  4. Second-order effect analysis is mandatory on each decision: SSR improves SEO but raises server cost and capacity planning; caching cuts latency but creates invalidation complexity and stale-data risk.
  5. The implementation plan breaks into granular tasks with dependencies identified, a risk table with mitigations, and a testing strategy split into unit, integration and E2E layers.
  6. Before production, the readiness checklist sweeps infrastructure, application, security, performance and operations items; red flags like unclear requirements or a missing rollback procedure stop the ship.
Use cases · what happens when you plug it in

One power source. 6 lines out.

architect · core

core active · 6 lines

  1. Writing a PRD or feature specification before implementation

    ✓ writing a prd or feature
  2. Choosing between monolith and microservices for a new system

    ✓ choosing between monolith
  3. Selecting a database and API paradigm for a project

    ✓ selecting a database and
  4. Documenting an architecture decision so future engineers understand the why

    ✓ documenting an architect…
  5. Designing a caching and indexing strategy for scale

    ✓ designing a caching and
  6. Running a production-readiness review before launch

    ✓ running a production-rea…
Benefits · what you walk away with

Yours to keep.

Drag time forward. Watch what stays.

Forever

That's what owning means.

The rented stack

ai writing tool: subscription

expired · access lost

analytics suite: subscription

expired · access lost

design platform: subscription

expired · access lost

(nothing left)

Your forge

  1. Decisions that survive scrutiny because the trade-offs are written down

    license: perpetual
  2. Less premature complexity by applying Occam's razor to every layer

    license: perpetual
  3. Fewer surprise outages thanks to blast-radius and second-order analysis

    license: perpetual
  4. Faster onboarding because the reasoning behind the system is documented

    license: perpetual

subscriptions expire · deeds don't

What's included · the full manifest

Everything in the box.

Pick a piece up. Watch it work.

A three-step planning workflow from requirements to implementation plan

part 01 of 06 · in the box

6 parts · one working system · ships instantly by email

Who it's for

This wasn't forged for everyone.

  • Not for you if you'd rather rent a tool than own one.
  • Not for you if you want someone else to run your stack.
  • Not for you if you're happy guessing.
Still here? Good.

Engineering leads, architects, and senior developers who plan systems and document the decisions behind them.

then this was forged for you.

Works with

Universal by design: these run in any AI. Delivered in the open Agent Skills + MCP format (native in Claude); ChatGPT, Gemini, Cursor and Copilot adapt the same files their own way.

  • Claude Native format
  • ChatGPT Adapts via open standards
  • Gemini Adapts via open standards
  • Cursor Adapts via open standards
  • Copilot Adapts via open standards
Questions · still in the air

Catch what's on your mind.

the air is clear. nothing between you and the forge.
catch a spark: the forge will answer

  1. My feature is small, is a full architecture toolkit too heavy?

    Scale the depth to the decision: a small feature might need only the requirements and data-design steps. The structured tools are there for choices that are expensive to reverse, like monolith versus microservices, not every checkbox.

  2. Does it pick the database and architecture for me?

    It forces each significant choice through a structured comparison so the decision is defensible, but the call is yours, made with the trade-offs laid out. It's a thinking framework, not an oracle that hands you 'use Postgres.'

  3. What do I actually walk away with?

    A PRD or specification and the documented reasoning behind your architecture: planning artifacts, not running code. Implementation is a separate step; this makes sure you build the right thing before you build it.

  4. How is it delivered?

    By email right after purchase: ready to run, downloaded instantly, no setup wait.

  5. One-time or subscription?

    A one-time purchase; no subscription or hidden fees. VAT (20%) is included.

  6. Can I get a refund?

    As a digital product, it can’t be refunded once downloaded. That’s why we show exactly what’s inside and who it’s for, right here.