Repository
A source container. It may hold one product, many capabilities, patterns, infrastructure and assumptions. A repository is never the reusable unit.
The library is the asset
We assemble applications from software that already works.
The internet holds billions of pounds of paid developer hours — written, tested, maintained, in production. Almost nobody assembles from it, because generation demos easily and assembly is hard to do well. Actionist's bet is that assembly beats generation once the seams are standardised, and that standardising the seams is the compounding, defensible part. We fork so we own the code, integrate natively so agents can change it, and rate it so selection improves without a human in the loop. Any single app is a demo of the library.
15moving parts mapped
3,010sources discovered
103carrying observed evidence
2blocks built
0admitted
Where we actually are
Computed from source on every build, and independently re-derived by a second program before it may ship. Not a summary someone wrote down.
3,010 sources discovered. 0 admitted. The pipeline has never completed end to end.
A total is not a state. Breadth is not progress; evidence is. The largest drop is Discovered → Triaged, losing 2,315 — but the decisive fact is that the last two stages have never been reached at all.
3,010Discovered
695Triaged
103Rated
2Forked
2Built
0Qualified
0Admitted
Capability source registryFRESHActionist blocksFRESHFramework registerFRESHSite page registryFRESHSystem partsFRESHComponent store (21st)FRESHGreat Library registryFRESHMac Mini discovery corpusDECLAREDGitHub discovery sweepsDECLARED
Words that must stay distinct
Most architecture confusion here came from using “block”, “repo”, “component” and “template” interchangeably. These are defined before the rest of the page uses them.
UI component
A visual or interaction primitive: a sidebar, hero, footer, table, card, picker or form state.
Capability block
A bounded outcome-bearing function with declared inputs, outputs, state expectations and host requirements. This is the reusable unit.
Packaging profile
How a capability is delivered: service, module, transplant, package, adapter, generated pattern or custom delta.
Archetype
An app-level workflow skeleton such as case management, client portal, CRM, scheduling or finance operations.
Assembly plan
The exact compatible capabilities, bindings, components, routes, data resources and glue required for one app.
Three lifecycles, three different objects. Candidate promotion (10 stages) describes a discovered source. Work maturity (5 values) describes a catalogue entry. Block admission describes an authored Actionist block, and is always scoped to a named host and tenant — never “reusable on the internet”. They look like they conflict; they do not. Do not merge them.
Who owns what, and what happens next
One owner per domain; contracts own the seams. If you need something from another domain, go through its contract rather than reading its internals. Anything crossing a seam is a contract change, not a local edit.
Components
The UI corpus: acquisition, taxonomy, curation, storage
Exposes · Canonical entity + alias set, normalised author/slug identity, Dynamic Search wire formatBlocks
Repo→block conversion, forks, the catalog
Exposes · The seven linked records; actionist/<name>@<semver> identityDiscovery
Mining all seams (Mini corpus, GitHub, industry scrapes)
Exposes · Rated candidates with provenance and evidence classComposition
Fitting blocks into an app
Exposes · AssemblyPlan, CompatibilityProof, UNDERDETERMINED questionsHost
Identity, tenancy, data, settings, navigation, connectors
Exposes · HostContractFront door
INTENT.md, the site, the state record
Exposes · INTENT.md, STATE.json, the published mapThe moving parts
Select a part to inspect what it owns, what research already tells us, what remains unresolved, and what a dedicated agent lane would work on. Notes are stored only in this browser.
The end-to-end loop
The client experiences one conversation. Underneath, several independent systems exchange typed outputs.
01Know clientExisting Actionist context + public business signals
02Discover outcomeConversation becomes a bounded ProductSpec
03Recommend capabilitiesNotion-like notes? Calendar? CRM? Portal?
04Choose experienceArchetype, layout, components and taste profile
05Solve compositionCompatible blocks fitted without model improvisation
06Bind hostData, identity, settings, connectors and runtime
07Normalize designSemantic tokens make independent pieces coherent
08Preview and editClient changes wording, layout, modules and behavior
09Verify and learnShip, observe, rerank assets and improve recipes
Composition is not code generation. The planner selects compatible capabilities and bindings; deterministic tooling installs and joins them; AI writes only the remaining semantic adaptation and glue.
Why generation-first builders lose
Not because they build badly. Because they made an architectural commitment — generate the whole application from a prompt — and every structural weakness below follows from it. A company can fix a bug. It cannot fix a commitment without becoming a different company. This is an argument, not a measurement; the measured part of this page is above.
They generate. We assemble.
A generated app is bounded by what one model can write inside one context window. An assembled app is bounded by the best software that already exists, plus the quality of the joins. Where proven code exists, proven code wins, and the gap widens every year the open-source estate grows.
They are good at layouts and CRUD and break on multi-step business logic — shipping wrong arithmetic.Their apps dissolve. Ours hold shape.
With no architecture underneath, edit 30 can quietly undo edit 5; the app has no structure to defend itself. Our changes are typed intent records bound to semantic anchors, so an edit either survives an upgrade or fails loudly. Silent regression is designed out, not tested out.
The #1 2026 complaint is credit burn on the model's own mistakes — 60 to 150 credits lost to AI-introduced bugs. Users pay to repair the generator.Every build of theirs starts at zero.
Pure generation has no memory: the thousandth app is produced by the same model against the same blank context as the first. We attach adaptation cost, workflow success and incident history to stable reusable units, so each build ranks the shelf for the next one. This is the advantage they cannot copy, because the thing that would learn is the thing they do not keep.
Their self-improvement loop tunes the generator. Ours improves the parts inventory.Constraining the problem deletes their worst liability.
Their generated apps talk near-directly to Postgres through PostgREST with row-level-security policies written by an LLM — a known data-leak class, with no dev/prod separation and everything publicly addressable. When the platform owns schema and policies, that risk does not get mitigated; it stops existing. Generality is what forces them to let the model write security rules.
ML6's architectural critique of the Lovable Cloud stack.House style versus a learned design system.
Pre-build style selection and even generation-time enforcement are table stakes — Lovable already scans every generation and auto-retries on token violations. The open ground is upstream and downstream of that: learning a client's actual preferences through structured comparisons rather than asking them to author a design system, and making an off-token value fail the build rather than trigger a retry.
Generic visual convergence is a reported Lovable outcome; no competitor found fails a build on token violation.A lookup is faster than a generation, and already coherent.
Their two-minute first render is a generation, so its quality is a sample from a distribution. Ours is a lookup into pre-baked stock under an already-chosen token pack, which is both faster in the limit and coherent on arrival. We are not trying to out-generate them; we are removing generation from the hot path.
Build and run credits were unified in June 2026, so a live app drains the build pool and users cannot attribute spend.The honest competitive frame: Lovable is the reference point, not the threat. Manus already ships the full-stack-app-from-one-prompt combination inside a cloud VM, at $100M+ ARR and roughly twelve months ahead architecturally, and free app-building bundled into Airtable and Zapier removes builder-as-premium-anchor entirely. The arguments above hold against generation-first builders as a class. They are the reason to benchmark against Manus rather than to feel comfortable.
Decided, and still open
What is settled, and what we are still betting on. A claim with no falsifier is not an answer.
Components ≠ taste
The gallery supplies visual pieces and inspiration. The preference learner discovers the client's design DNA.
Repos ≠ blocks
A repository must be understood and assigned a reuse shape before it enters the reusable shelf.
Postgres ≠ universal interface
Use typed data capabilities; keep Postgres as the default for new transactional state we own.
Solver before model
Compatibility, dependency and authority elimination should be deterministic before AI chooses alternatives.
Licence is not a selection input
Select on code quality and product fit. Licence is metadata with zero weight; rights matter at admission, never at selection.
Hand-curated top 100
A deliberately chosen first shelf may teach us more than another million metadata records. With 103 sources carrying observed evidence, this remains untested.
Case/portal pilot
Demand appears stronger and reusable supply thinner than for generic dashboards, making it a better test.
Framing is debt
Both built blocks mount as intact services rather than native forks. Framing costs theming, layout, navigation and code access — the whole asset. Each needs a named path to absorption.