Force the technology where it does not fit.
Trend pressure replaces engineering judgment. Cost, uncertainty, and unnecessary decision points accumulate while a simpler deterministic answer was available.
Aiming for real multipliers —
not just gains
AI-Assisted
Architecting
Disciplined approach to cohesive
and transformative efforts.
Engineering is nothing like in 2025.
Recent advancements are not mere improvement - they are a leap. AI-powered tools became capable of breaking into all knowledge work territories: from low-level coding to architecture and design, to operating complex systems autonomously.
Latest
All of it
Cheetah documentation, updatedOne maintained set, ordered the way the project intends it to be read: getting started, the system explained, building and operating it, and the exact contracts at the end.
The unit of work movedLonger autonomous runs made human input rarer, later and higher-stakes, which moves the binding constraint from review capacity to the supply of well-formed direction.
Reading a codebase, on the recordOne complete examination of a 379-file project, end to end — every command as typed, every number as returned.Majority of companies still fail to realize the full potential.
We see brilliant initiatives fail even where the tools and the talent are there - for lack of consistency, of principles, and of a clear understanding of the scale of the change: the shift in emphasis and level of intervention, the potential failure modes, and recognizing dead ends on time.
Isolated gains do add up. They don't multiply.
Recognizing the bottlenecks, frictions and uncertainties is what switches scattered, opportunistic gains into real multipliers in throughput - at project or even company level. Seasoned professionals can, and do, evolve their own practice, combining agents and tools in novel ways for their own projects.
Lab429 is an initiative to distil the lessons of real projects into principles. Discipline first, good practice, established conventions.
Recurring root causes
From practice we have identified the most repetitive root causes of bottlenecks and showstoppers - the ones that make a transition fail, or fall far behind its potential.
-
Granularity
Work in the largest unit that can still be verified, so progress is not assembled from thousands of fragile decisions.
-
Interaction
Move discussion and approval above code fragments, into plans and documents that outlive the conversation.
-
Overview of flows
Keep several lanes of work visible at once, so nothing stalls unnoticed and attention goes where it is actually needed.
-
Verification
Make checking cumulative and varied instead of restarting every investigation from the visible surface.
-
Application interaction
Let applications offer higher-level operations, so intelligence meets them at the right altitude instead of clicking through the surface.
The thesis
AI everywhere is not a strategy.
- Exponential uncertainty
- Cost
- Slow
- Non-deterministic
Changes are transformative, but the easy way and one-size-fits-all attempts systematically fail. Getting it efficient across workflows, company-wide practices, the work of individuals, interacting and organizing is notoriously complex, while hype-driven posts and videos present deceptively simple slices of the magic.
We share the insights gathered across projects, consultations and debates, together with the practices around them, and an initial look at the continuously evolving tooling we use to analyze and transform the way we work — so that 2026 is really not like 2025, and sometimes to give an impression of how 2027 will look.
Addressing cherry-picked aspects without discipline, and failing to embrace a holistic perspective - at enterprise level, at team level, or at an individual's level - can hurt anywhere on the range from suboptimal results to a fall in performance, and on to dead ends or outright failure. Inconsistent adoption also creates tension in operations and between teams.
We see both failure modes emerging in recent transformations at every scale of project: overuse or misuse of technologies where they do not fit, and missed opportunities where they would.
- Working on projects, and rescuing ones that are otherwise brilliant initiatives or useful pilots, you recognize how much the correct processes and proper granularity affect the outcome. Forcing technologies under pressure from trends often costs more than it gains.
- The opposite is also true: paralysis in the face of complexity, lack of insight, or an early failure leaves the real multipliers untouched.
Retreat after the first complexity or failure.
The opposite mistake leaves the real multipliers untouched: larger units of work, parallel operations, accumulated insight, and systems that improve from repeated use.
The pillars
Five places where the working level must rise.
Each pillar can help alone. The multiplier comes from treating them as one system: how work is divided, where people interact, what remains visible, how understanding is verified, and how intelligence reaches the outside world.
Based on building our own projects and on assisting and consulting on others, we see - as everywhere in software development - a few pillars that have to be right, and in balance, for the work to produce a real multiplier rather than friction or a diminishing gain. Depending on the project, all or some of them contribute to the overall throughput multiplier.
All of them reach back to the same concept: Elevate!
01Cheetah ↗
02Arboretum ↗
03AWACS ↗
04Paladin ↗
05Imprint ↗
Troveholm ↗
Granularity
Build on a proven substrate so product work starts with meaningful operations, not another pile of connective machinery.
Interaction
Move discussion and approval above code fragments into durable plans, documents, relationships, and decisions.
Overview of flows
See several work lanes at once and route attention to the place where a person is actually needed.
Verification
Make examination cumulative, varied, and persistent instead of restarting every investigation from the visible surface.
Application interaction
Use intelligence to discover the answer once, then carry repeated work with fast, inspectable machinery—proven inside products such as Troveholm.
Building on all five
A browser companion that keeps a durable, private memory of what you already worked out, and puts it back beside the page. The first product standing on the whole stack.
The tools are not the practice. They carry practices learned across projects, consultations, failures, and repeated use—and they keep those practices available when the models and vendors change.
Granularity
See how Cheetah carries the substrate ↗
Do not rebuild the distributed middle for every idea.
Choosing the right granularity means reducing the number of decisions a system has to get right. Agentic coding makes it easy to assemble new components and locally sensible patterns, but every added boundary and decision point is another place for the whole flow to fail, and correctness decays with the length of the chain. We therefore prefer a small number of proven, comprehensive building blocks, and build a shared substrate when the same application patterns keep returning across projects. Cheetah grew out of exactly that need: one stable base for clients and distributed roles, across devices and system architectures.
StartOne process
A rough concept, one client, in-memory infrastructure.
ComposeSeveral real clients
Browsers, extensions, Node processes, and first-party pages.
OperateDistributed roles
Durable identity, delivery, coordination, policy, and failure handling.
Interaction
Too low
Too detached
See Arboretum’s document-centred approach ↗
The argument is not code versus no code.
Both extremes hold attention at the wrong altitude. The useful question is where people should retain judgment: architecture, structure, boundaries, security surfaces, essential flows, and the decisions that shape the whole system.
Elevating interaction means choosing the level at which people keep judgment over a system. Both extremes fail: staying at the curly brackets makes a project slow without buying the quality it claims, while working from observable outcomes alone loses architecture, data, boundaries and security surfaces - everything that decides whether the system survives its next change. The right level depends on the task, the criticality of the component, and what the agents can actually do today. Arboretum exists because those decisions deserve a durable surface, not a chat window.
Curly-bracket control
Human attention stays inside implementation details. Quality may improve locally while the project loses the strategic advantage of larger units of work.
Unstructured vibe coding
The code remains visible, but architecture and intent disappear. Local changes accumulate without a reliable view of what the system has become.
Raise the interaction surface: plans, evidence, decisions, diagrams, and documents that remain connected to the implementation.
Overview of flows
See how AWACS observes attention ↗
Parallel work needs a view above the individual agent.
Serious work crosses branches, computers, operating systems, vendors, capability levels, and cooperating agents. The signals exist, but they remain trapped inside separate applications. The scarce resource is no longer keystrokes—it is well-routed human attention.
Elevating the overview means seeing several lanes of work at once, above any individual agent. The signals that matter - who is waiting for a person, what finished quietly, which collector stopped reporting - exist, but they stay trapped inside separate applications, on separate machines, behind separate vendors. So the ceiling on parallel work is not compute or quota; it is how many places one person can keep looking. AWACS came from that: one field to scan, so attention goes where it is actually needed.
Work lanesAttention routing
Architecture review
Running
Browser client
Needs decision
System tests
Verifying
Documentation
Waiting
Verification
Check the change. Examine the system.
AI did not make verification important; it changed what can be examined and how often. Tests, reviews, and pipelines remain necessary near a change. They still do not expose slow architectural drift, forgotten assumptions, neglected regions, or the gap between a project and the world around it.
Elevating verification means making examination cumulative instead of starting it again every time. An investigation that begins from the visible surface pays twice for understanding already bought, and findings that live in a chat window evaporate with it - which is how systems accumulate dead code, forgotten assumptions and decisions that no longer fit. What works is directed variation: intent is set by a person, examination roams deliberately across parts and angles, and what was checked, learned and left uncertain is written down, so a rejected idea stays knowledge. Paladin keeps that memory, though the practice matters more.
Verify the change
Use tests, diffs, paired agents, and explicit review loops while work is being created, merged, and deployed.
Patrol the accumulated system
Move attention deliberately across components and viewpoints. Keep what was examined, what was learned, and where uncertainty remains.
The method
Explore. Distil. Run. Then learn from the running system.
01
Explore
Use people and models where the path is genuinely uncertain and judgment creates value.
02
Distil
Turn what worked into procedures, parsers, components, architecture, and durable knowledge.
03
Run
Let predictable machinery carry repeated work, then feed real experience back into the next refinement.
The work
The tools that carry the practices.
Some are substantial systems; some are focused utilities; one is a deliberately small proof product. Their common purpose is to move work to a more useful level without pretending every problem needs another model call.
SubstrateOpen the product page ↗
DistillationOpen the product page ↗
InteractionOpen the product page ↗
VerificationOpen the product page ↗
OverviewOpen the product page ↗
Proof productOpen the product page ↗
Cheetah
Connected applications without rebuilding the distributed middle.
Imprint
Pay for interpretation once; run the resulting parser repeatedly.
Arboretum
Keep project-wide insight in documents rather than transient chats.
Paladin
Make investigation cumulative, attributable, and explicit about what it has not examined.
AWACS
Know which work lane needs a person across several concurrent projects.
Troveholm
A small real application assembled on the shared substrate.
The direction
Principles first. Tools second.
Use intelligence where the path is genuinely uncertain, keep human judgment at the altitude where it decides the shape of the system, and let deterministic machinery carry what is already understood. What comes out of that stays portable beyond any one model or vendor — which is the point of putting the principles before the tools.