Skip to content
Strevian

You lead with vision.
We build the software.

Every product we build runs on one rule: people make the decisions, machines do the work, and everything is logged.

Forge / 6 phases / 14 flows / 62 modules

Forge, the platform we build with, runs every product through six phases. Four move forward. Two run for as long as the product is live, and feed what they learn back into the next idea.

The Forge loop: six phases from Define to Operate, and Learn feeding Define again.
  1. Phase 01 / Define

    Define

    Decide what matters: who it is for, why it should exist, and what cascades from the organization down to the feature.

    • Portfolio6 modules
    • Vision4 modules
    • Brand3 modules

    Portfolio Canvas

    Visualizes the tree of organizations, teams, products, and features.

  2. Phase 02 / Create

    Create

    Design it properly: tokens, components, pages, the backend schema, and a plan with the decisions written down.

    • Design3 modules
    • Service7 modules
    • Playbook4 modules

    Token Engine

    Three-tier tokens (style, brand, theme) with brand forking and change preview.

  3. Phase 03 / Build

    Build

    Agents generate, test, and prove. A person reviews every merge.

    • Dev8 modules
    • Deploy4 modules

    Review Station

    Agent self-review, then human review of proofs and plan match.

  4. Phase 04 / Grow

    Grow

    Content, campaigns, and search, planned from the same source of truth.

    • Growth3 modules

    Campaign Planner

    Email sequences, drip flows, promotions, ad creative.

  5. Phase 05 / Learn

    Learn

    Usage, patterns, and feedback, turned into hypotheses you can test.

    • Insights5 modules
    • Feedback2 modules

    Hypothesis Lab

    Structured hypotheses, A/B tests behind flags, results tracking.

  6. Phase 06 / Operate

    Operate

    Incidents, policies, and security, watched continuously once anything is live.

    • Ops5 modules
    • Legal4 modules
    • Security4 modules

    Incident Commander

    Incident workflow, on-call rotation, postmortems.

Visibility. No silent surprises.

Before Forge moves a node, changes a schema, deletes anything, or touches a permission, it shows exactly what will happen. Then it asks. Nothing runs outside that pipeline, and nothing changes without a person saying yes.

A person reads the diff.

Agents write the code and the tests, record a visual proof, and review their own work first. Then a human reads it and decides. That review is the final gate on every merge, in Forge and in every project we build.

The wall

Every stage runs on every commit, in order. CI blocks any merge that fails one. Then, and only then, a person reviews it.

HUMAN REVIEW. THE FINAL GATE, NOT A STAGE.

Past the tenth stage, a person reads the change. Nothing merges on green alone.

Merged
Commite41b7c0
10Security

MERGE BLOCKED. NOTHING DOWNSTREAM RUNS.

Interface fragment.

FIRST EXECUTION OF THE WORKFLOW GUARD: 5 REAL SECURITY DEFECTS CAUGHT.

Engineering standard

Strevian works to a locked engineering standard. Every project inherits it through a thin profile, and machines check it before a person ever reads the code.

  1. 0

    R1 to R20

    Rules every project inherits.

  2. 0

    CHK-01 to CHK-82

    Checks in the catalog.

  3. 0

    G0 to G5

    Release gates.

  4. 0

    Q1 to Q12

    The quality model.

  5. 0+

    30+

    Decision records, written in plain language.

  6. 0

    152

    WCAG AA pairs checked in CI, across every brand and theme.

  7. 0

    1

    Mechanism registry: adding a mechanism requires written justification.

Building now
Currently building
Forge
Slice 0: the Portfolio walking skeleton
  1. Standard

    Quality model Q1 to Q12 added: the ladder from impossible to detected to tested to reviewed to production.

  2. Standard

    Agent-operations standard A1 to A12: how an agent-operated development ecosystem is stood up and run.

  3. Decision record

    ADR-0030 addendum: Forge v1 is greenfield-only. Brownfield import is a deliberate v2 decision, not a silent absence.

  4. Decision record

    ADR-0030: architecture batch-apply. Two-tier platform census locked, Notification Hub and Integration Hub added.

  5. Decision record

    ADR-0027 to 0029: UI stack re-chartered on the Tactile design system, build commit type, tighten-only coverage ratchet.

  6. Wall check

    Delivery wiring merged to main. All four required checks green on the first protected merge.

See everything we have shipped

Services

We build prototypes, foundations, and whole products for founders and creators, on the same standard Forge is built with. Every price below is the price.

Closest fit
2 WEEKS

Prototype Sprint

$4,800

A real, clickable, deployed prototype of your idea on a production-grade design system. Not a Figma mock: real code you keep.

What you keep

All code and IP, yours from day one.

4 WEEKS
THE FOUNDATION THE REST IS BUILT ON

Founding Sprint

$14,000

Idea to validated architecture, your brand and design tokens, a harnessed repository with the wall, and the first working slice deployed.

What you keep

All code and IP, yours from day one.

8 TO 12 WEEKS

Full Build

from $36,000

The complete product, shipped.

What you keep

All code and IP, yours from day one.

ONGOING. PAUSE ANYTIME.

Studio Partner

$7,500 per month

Strevian as your product engineering partner.

What you keep

All code and IP, yours from day one.

Included

Every engagement includes.

  • 01

    Human review as the final gate on every merge.

  • 02

    Impact previews before consequential changes.

  • 03

    Recorded visual proofs.

  • 04

    Plain-language decision records.

  • 05

    Full ownership of code and IP.

The person

I'm Wesley Deitch. Strevian is my studio, and I do the work. I built Forge, the platform we build with, and the standard it runs on: twenty rules, eighty-two checks, six release gates, and a wall every commit has to pass.

Agents write a lot of the code. They do not decide what gets built, and they do not merge anything. I read every diff.

I take one product at a time, because that is the only way I know to do this properly.

Wesley Deitch

Founder
Wesley Deitch
Capacity
One product at a time
Review
Human, on every merge
Agents
Behind the wall
Logs
Every action
Currently building
Forge
Forge

Forge is the AI-powered development platform we build our own products with: 6 phases, 14 flows, 62 modules, from the first idea to the running product and back.

It is in internal use now. It goes public when it is mature, and not before.

See how Forge works
Waitlist

No newsletter. No tracking. One email when it matters.