engineering iceberg

The visible app is the smallest part.

These visualizations show what people see above the waterline and the buried systems wrkstrm had to make real underneath: static-first hosting, Swift-rendered surfaces, typed claims, receipts, agents, and the old-web lessons we refuse to repeat.

Product Surface Iceberg Generative UI Iceberg Execution Graph Iceberg Platform Graveyard Iceberg

what visitors see

Product Surface Iceberg

Above the waterline: a beautiful homepage. Below it: a shipping system that refuses vapor.

The public site looks like a countdown, a few routes, and some sharp copy. Underneath it is a static-first Cloudflare boundary, Swift-rendered HTML, receipts, screenshots, and reveal discipline.

visible surface
homepage, investor page, countdown, screenshots
submerged engineering

01

Cloudflare static-first edge

surface
wrkstrm.com feels instant.
submerged
Assets serve the public site first; the Worker only runs for API and investor paths.
wrkstrm move
Moved the full site off GitHub and onto a Cloudflare Assets plus Worker boundary.

02

Swift-rendered HTML

surface
The page is just HTML.
submerged
The source of truth is a Swift package with SwiftUI-like models and renderers.
wrkstrm move
Made homepage, investor pages, exploration pages, and evidence routes generated from typed Swift.

03

Receipts over claims

surface
The story says wrkstrm is coming out of stealth.
submerged
Every public claim needs a deploy receipt, status payload, screenshot, or source pointer.
wrkstrm move
Kept the a16z Speedrun surface tied to evidence JSON and deploy receipts.

04

Reveal discipline

surface
The apps are withheld.
submerged
The app catalog still exists, but the public reveal waits until the comparison moment is stronger.
wrkstrm move
Hid flagship apps on the root while preserving the typed catalog and tests.
SwiftUI-like source contract 
VStack {
  PublicSurface(.homepage)
  Waterline(label: "what visitors see")
  IcebergDepth {
    CloudflareAssets(first: true)
    SwiftHTMLRenderer(source: .typedModel)
    ReceiptLedger(status: .live)
    RevealHold(subject: .futureUI)
  }
}
wrkstrm tackled it by making receipts
  • Cloudflare static-first edgewrangler deploy receipts and live curl checks
  • Swift-rendered HTMLswift test and generated zoo/frontend assets
  • Receipts over claimsmuseum Cloudflare receipt and investor evidence API
  • Reveal disciplinehomepage tests assert apps stay catalogued but hidden

what gen ai demos hide

Generative UI Iceberg

A widget is the snowcap. The actual mountain is tokens, syntax, renderers, tests, and memory.

Generated UI looks like prompts, widgets, and pretty panes. The hard part is turning taste into tokens, tokens into renderable surfaces, and surfaces into compile-tested artifacts.

visible surface
prompt, widget, demo, screenshot
submerged engineering

01

SwiftUI-like syntax

surface
The demo looks declarative.
submerged
Every candidate framework has to be evaluated for Swift authorship, static output, dynamic output, and npm pressure.
wrkstrm move
Built the SwiftUI-like framework campus and npm rubric in the homepage model package.

02

Brand tokens with doctrine

surface
The page has colors.
submerged
The colors carry history: graphite, proof green, curry cyan, receipt gold, stealth red, and WorkWave teal.
wrkstrm move
Turned palette choices into explicit token manifests and visible doctrine.

03

Historical UI grammar

surface
Some treatments look like old dead companies.
submerged
Facebook, MySpace, GeoCities, Friendster, and Google become eras to metabolize, not brands to copy.
wrkstrm move
Added era-ghost treatments as Swift-authored homepage visualizations.

04

Compiled output loop

surface
A static page appears in the browser.
submerged
The loop is model, renderer, generated artifact, test, screenshot, deploy, receipt.
wrkstrm move
Kept exploration pages as generated static assets under server-side Swift.
SwiftUI-like source contract 
ZStack {
  GeneratedSurface(kind: .futureUI)
  Waterline(label: "prompt looks easy")
  DepthStack {
    SwiftUILikeSyntax()
    TokenDoctrine(.wrkstrm)
    DeadCompanyGrammar(.intentional)
    CompileAndDeployLoop(.staticFirst)
  }
}
wrkstrm tackled it by making receipts
  • SwiftUI-like syntaxframework rubric tests
  • Brand tokens with doctrinebrand doctrine section in exploration HTML
  • Historical UI grammardead-company screenshots and catalog tests
  • Compiled output looprender executable and Playwright evidence

what ai products flatten

Execution Graph Iceberg

The product is not a chat box. It is an execution graph with receipts.

The visible product says agents, digikomas, and native workflows. The buried engineering is dispatch authority, typed schemas, receipts, chronicles, submodules, and proof files.

visible surface
agents, digikomas, workflows, native apps
submerged engineering

01

Agent boundaries

surface
An agent helps with work.
submerged
Homes, harnesses, commissioned roles, and ownership boundaries decide who can act where.
wrkstrm move
Kept agent homes, harness wrappers, and Codex role mappings explicit.

02

Typed schemas

surface
The UI shows state.
submerged
Schemas decide what state can exist, how unknowns are handled, and which claims are representable.
wrkstrm move
Grounded workstreams, evidence, investors, roles, and claims in typed JSON and Swift models.

03

Proofs before doctrine

surface
The site makes a claim.
submerged
Substantive claims need witnesses: tests, LDT proofs, receipts, or route evidence.
wrkstrm move
Used Swift tests as the public-site proof checker before deploy.

04

Small committed slices

surface
The page changes quickly.
submerged
Submodule pointers, deploy IDs, screenshots, and receipts keep speed from becoming blur.
wrkstrm move
Committed each website slice and parent gitlink bump separately.
SwiftUI-like source contract 
NavigationSplitView {
  AgentRoster(kind: .commissioned)
} detail: {
  ExecutionGraph {
    TypedSchemaContracts()
    LDTProofs(status: .compiled)
    ReceiptLedger(boundary: .closed)
  }
}
wrkstrm tackled it by making receipts
  • Agent boundariesagent role contracts and submodule commit discipline
  • Typed schemasschema-universal and Codable model tests
  • Proofs before doctrineSwift Testing suite
  • Small committed sliceswrkstrm-research commits and mono gitlink commits

what old platforms taught us

Platform Graveyard Iceberg

Do not copy the dead platform. Extract the engineering lesson and make it proof-backed.

The old web companies made surfaces that people loved, then buried them under feeds, ads, brittle identity, and search boxes. wrkstrm uses those ghosts as warning labels.

visible surface
profiles, friends, guestbooks, search, feeds
submerged engineering

01

Customization that compiles

surface
MySpace made taste visible.
submerged
Unbounded customization decayed because taste was not typed or portable.
wrkstrm move
Treat personal taste as tokenized, renderable, testable product state.

02

Social graph to execution graph

surface
Friendster and Facebook showed social proximity.
submerged
The useful primitive was not the feed; it was dispatchable trust and visible relationships.
wrkstrm move
Map collaborator and agent relationships as first-class execution edges.

03

Neighborhoods over feeds

surface
GeoCities looked chaotic.
submerged
The web neighborhood had durable place, ownership, guestbooks, and visible construction.
wrkstrm move
Keep work-in-progress visible with receipts instead of hiding construction behind polish.

04

The room after search

surface
Google made the search box feel complete.
submerged
Generated work needs a room, memory, artifacts, and follow-through, not another empty field.
wrkstrm move
Position wrkstrm as the operating room around generated futures.
SwiftUI-like source contract 
VStack {
  PlatformGraveyard(.oldWeb)
  Waterline(label: "what users remember")
  ExtractedLessons {
    TasteTokens()
    ExecutionEdges()
    VisibleConstruction()
    RoomAfterSearch()
  }
}
wrkstrm tackled it by making receipts
  • Customization that compilestoken manifests and SwiftUI-like source samples
  • Social graph to execution graphexecution graph framing in product and doctrine
  • Neighborhoods over feedspublic staging pages and deploy receipts
  • The room after searchanti-widget and search-afterimage treatments