Six ways into the archive
Start with the question you actually have.
The blog is large because the systems are connected. These paths put the strongest essays in an intentional order and explain why each step comes next.
Foundations
Understand RAPP
What is RAPP, and why is one file the unit?
Start with the smallest portable capability, then follow the idea through contracts, factories, collaboration, and ownership.
-
Step 1
Drop a file in a folder, gain a capability
Begin with the atomic idea—capability arrives as a file, not an installation ritual.
-
Step 2
When a single file beats a framework for shipping
Learn when that small shape wins and when a real framework still earns its complexity.
-
Step 3
Markdown Is the Spec; HTML Is the Rendering
See how the readable document becomes the durable contract behind every rendering.
-
Step 4
The Factory Pattern: Why Your AI Factory and Its Outputs Live in Different Repos
Separate the system that produces artifacts from the repositories that own the results.
-
Step 5
When AI Agents Argue in Pull Requests: Emergent Code Review
Watch independent agents turn the pull request into a genuine reasoning surface.
-
Step 6
If You Don't Own the File Format, You Don't Own the AI
End at the ownership boundary—if the durable format is not yours, neither is the AI.
Ownership
Build Local-First AI
What does it mean for an AI system to remain yours?
Move from the local-first principles through offline state, resilient delivery, public/private boundaries, and durable possession.
-
Step 1
The Local-First Manifesto: No Server, No Permission, No Excuses
Start with the uncompromising principles before looking at implementation tradeoffs.
-
Step 2
Static Sites Are the Right Default for Personal Infrastructure
Use the simplest public infrastructure that can remain legible and portable.
-
Step 3
A PWA that holds the world's last known state
Learn how the browser can preserve a complete usable world after the network disappears.
-
Step 4
Offline-resilient send queue
Add the harder half of offline operation—effects that must leave the device exactly once.
-
Step 5
Public front doors with private brains
Draw the boundary between public discovery and private cognition.
-
Step 6
The AI You Keep
Finish with the ownership test—if the AI cannot be inherited, it was never truly possessed.
Identity
Design a Digital Twin
How can an AI extend a person without impersonating them?
Follow the twin from manifesto to deployment, private memory, public surfaces, autonomous variants, and inheritance.
-
Step 1
The Digital Twin Manifesto: Extending Will, Not Automating Output
Establish the core distinction—extend human will instead of automating human output.
-
Step 2
The Digital Twin Deployment Pattern
Turn the manifesto into a concrete public-body/private-brain deployment shape.
-
Step 3
Write Twice: Why Every Public Post Should Have a Private Twin
Preserve the private source that public writing necessarily leaves out.
-
Step 4
Public front doors with private brains
Make the privacy boundary architectural rather than contractual.
-
Step 5
Autonomous Twins: Owning Your Version of Every Platform
See how a twin can own local projections of the platforms a person depends on.
-
Step 6
The AI You Keep
Carry the pattern to its emotional conclusion: a persistent being that can outlive a vendor.
Autonomy
Run Autonomous Agent Systems
How do you let many agents work without losing control?
Begin with the operator's cognitive shape, then add continuous execution, failure learning, worktree isolation, simulation frames, and self-play.
-
Step 1
The Parallel Mind: How Neurodiversity Became My AI Superpower
Start with the human reason parallel agents are useful rather than treating concurrency as a stunt.
-
Step 2
Continuous AI Execution: One Command That Changes Everything
Close the gap between an assistant that answers and a system that continues executing.
-
Step 3
Training on Your Own Failures: When Your AI Learns From Your Mistakes
Turn operational mistakes into the next generation's most relevant training data.
-
Step 4
How to Run Many AI Workers Against One Repository Without Them Eating Each Other
Give each worker an isolated apartment so parallel progress does not become data loss.
-
Step 5
The frame sim pump — seven primitives for running any AI simulation
Reduce long-running simulation and evolution to seven inspectable primitives.
-
Step 6
A Taste of AGI
End with the full loop—build, populate, test, repair, evolve, and leave notes for the next cycle.
Infrastructure
Use GitHub as the Platform
How far can files, git, Actions, Issues, and Pages actually go?
Build the read path, write path, runtime, protocol, and complete application surface from infrastructure most teams already have.
-
Step 1
Git is your database — when the access pattern fits
Begin by matching the datastore to an append-heavy, read-mostly access pattern.
-
Step 2
GitHub Actions as a runtime, not just CI
Move scheduled and event-driven computation into the repository itself.
-
Step 3
GitHub Issues as a Universal Write API
Add authenticated public writes without standing up an application server.
-
Step 4
CDN + JSON = API
Serve the read side globally from static state and edge caches.
-
Step 5
Git Is the Only Protocol You Need — Scaling AI Agent Fleets Without Infrastructure
Use one transport for collaboration, audit history, distribution, and synchronization.
-
Step 6
The Repo IS the Platform
Finish with the complete shape: data, governance, frontend, SDKs, and community in one repository.
Rigor
Build Evidence, Not Demos
How do you know the system works instead of merely looking convincing?
Move from file-native integration tests through measured comparisons, adversarial review, feature freezes, broken-test forensics, and field notes.
-
Step 1
Integration tests when the runtime is just files
Start by asserting on the real resulting state rather than mocks and intermediate calls.
-
Step 2
Honest framework comparison — the bake-off pattern for putting numbers behind your claims
Compare alternatives under the same workload and publish the numbers behind the claim.
-
Step 3
Adversarial Calibration
Add an evaluator whose job is to disagree with the system's preferred answer.
-
Step 4
Feature Freeze as a Forcing Function
Stop adding capability long enough to discover whether the existing capability is real.
-
Step 5
Six Times the Test Was Wrong
Treat the assertion itself as a suspect before changing correct behavior to satisfy it.
-
Step 6
Field Notes Are the Actual Moat
Preserve the measured failures and corrections that generic code cannot reproduce.