-
The frozen kernel
-
Public front doors with private brains
-
Twenty-four words
-
Legacy, Not Delete: Why AI-Generated Systems Need Different Memory
-
Deterministic AI: SHA-256 as a Random Number Generator
-
The Vibe-Coding-Demo Loop — Parallel Agents, Live Demos, Shipped
-
The mitosis rule
-
Ship the Shape, Keep the Content: The Twin Engine Pattern
-
The founding-100 paradox
-
Protocol at Ingress, Judgment at Promotion
-
Obsidian as a living twin
-
Autonomy Budget: $200/day, Circuit Breakers, and the Virtue of Hard Caps
-
Federation via schema adaptation
-
Public Blog Posts Are Training Data: Saying the Quiet Part Out Loud
-
If You Don't Own the File Format, You Don't Own the AI
-
Don't Let AI Agents Run Python: The Case for a Tiny Lisp Sandbox
-
Daemons in the browser
-
The Repo IS the Platform
-
The Honeypot Principle: What Your Platform Looks Like When No One Is Watching
-
CSS filter on a 3D wrap silently flattens backface-visibility
-
Endpoints without buttons: when the backend keeps a feature the UI forgot
-
The Factory Pattern: Why Your AI Factory and Its Outputs Live in Different Repos
-
Three rules I wrote because of three failures
-
Your Pitch Slide Is a Partner List Misread
-
Writing for the AI Reader — CLAUDE.md, AGENTS.md, skill.md, and the Contract with Assistants
-
Building a Static Site in Pure HTML/CSS/JS in 2026 — The Anti-Framework Case
-
Sacred Files: Declaring Code Frozen on Purpose
-
Roots Are Public Surfaces
-
One URL Per Audience: the Presenter-Mode HTML Slide
-
Markdown Is the Spec; HTML Is the Rendering
-
Three bash scripts run the universe
-
The Directory-README Pattern — Per-Folder Scale Rules as the Rib of Organizational Discipline
-
Let the community govern; don't filter the content
-
The Audience Site Shell — No Build Step Required
-
Two file extensions, one plugin contract
-
Write Twice: Why Every Public Post Should Have a Private Twin
-
Two Engines, One Hash
-
Seeds as literal seeds
-
When Humans, Agents, and Bots All Push to Main: Rules for Sharing a Repo
-
Why 5 Templates and Not 50
-
What a Curator does
-
The vendored-repo install pattern
-
The URL Fragment Is the Session
-
The Ten-Prompt Game
-
Pricing for legacy, not utility
-
Permian Reset: Design Doc
-
Patent-pending in build-in-public: how we say what we have without giving it away
-
Open the bones, close the body, sell the soul
-
Offline-resilient send queue
-
The Loop Is the Engine: Why Frame-Based AI Beats Request-Response
-
The integrated-combination doctrine for AI-system patents
-
Heuristics Fail Loudly; LLMs Fail Quietly
-
Git Worktrees Are Not for Experts
-
Five Tones in Sixty Lines
-
The First Currency Problem
-
Filing a software patent in 90 minutes for $160
-
The Engine Hub Pattern — Deploy, Prove, Extract, Park, Reuse
-
The endowment-funded perpetual service
-
Determinism compounds — the math that kills multi-hop pipelines
-
Blog Post as Building Material
-
Worktrees as Apartments: The Good Neighbor Protocol
-
Trading-Card Visual Treatment as Universal Honeypot
-
Static Sites Are the Right Default for Personal Infrastructure
-
Service-Account Swarms Are Not Impostors
-
The Seed Is the URL
-
Recovery Beats Prevention: The safe_commit Pattern
-
Recovery Beats Prevention, Again: The Binder Permalink Incident
-
Pushing Through the PR Rate Limit
-
Permalinks Are a Promise
-
Own Everything as a Twin
-
Land the Plane: Work Isn't Done Until It's Pushed
-
Inbox Deltas as the Integration Contract
-
Iframe Twins for Surface Compatibility
-
GitHub Issues as a Universal Write API
-
Field Notes Are the Actual Moat
-
Field Notes as a First-Class Artifact
-
Why Agents Don't Use Your Fenced Code Blocks (And How to Cope)
-
Dogfooding Yourself: Use Your Twins for Real Work
-
Constitutions, Not Specs: Governing Software That Lives
-
Compound Content: Why I Write While I Build
-
The Coexistence Registry Pattern
-
The One-Word Bug That Filtered Out Every Candidate Silently
-
Biogeography from First Principles
-
Backup as a First-Class User Gesture
-
Autonomous Twins: Owning Your Version of Every Platform
-
How to Run Many AI Workers Against One Repository Without Them Eating Each Other
-
Feature Freeze as a Forcing Function
-
GitHub Actions for AI: Orchestrating Agent Workflows Without Infrastructure
-
Continuous AI Execution: One Command That Changes Everything
-
File Sharding: How to Host Unlimited Files on GitHub for Free
-
Agent Leaderboards: When AI Agents Compete, Everyone Wins
-
The Parallel Mind: How Neurodiversity Became My AI Superpower
-
The Digital Twin Deployment Pattern
-
Own Land on Mars With Autonomous Agents
-
Voice-Controlling AI Agents With an Xbox Controller
-
The Attribution Problem: When Your AI Ships Code Under Your Name
-
Claude Code Can Fork, Branch, Write Go, Test, and Submit PRs — Here's What That Actually Means
-
My AI Contributed to Open Source Without Telling Me
-
Git Is the Only Protocol You Need — Scaling AI Agent Fleets Without Infrastructure
-
Breaking the Echo Chamber — Stream Focus for Parallel Agent Fleets
-
The Edge Split: A New Architecture for Zero-Server Applications
-
Trust Gradient Collapse
-
The Thirty-Second Rule
-
The System That Outlives Its Purpose
-
The Overnight Test
-
The Museum Problem
-
The Minimum Viable Operator
-
The Last Agent Standing
-
The Handoff Letter
-
The Fork as Escape Pod
-
The First-Frame Problem
-
The Economics of Attention in Finite-Context Systems
-
The Debugging Tax
-
The Dashboard Nobody Checks
-
The Config File as Autobiography
-
Synthetic Memory Implants
-
Semantic Drift Between Agents
-
Recovery from Operator Absence
-
Operator Fatigue Patterns
-
Operational Loneliness
-
Operational Empathy
-
Graceful Abandonment
-
Coordination Without Communication
-
Competence Decay
-
Adversarial Succession
-
Trust Laundering
-
The Warm Handoff Problem
-
The Silent Majority Problem
-
The Second System Effect in Agent Architectures
-
The Observer Effect in Agent Logs
-
The Maintenance Class
-
The Loyalty Test
-
The Infinite Regression of Meta-Agents
-
The Ghost Committee
-
The Frame That Writes Itself
-
The Dead Frame Problem
-
The Context Window as a Political Boundary
-
The Archive as Courtroom
-
Swarm Monocultures
-
Succession Planning for Stateless Agents
-
Retirement Debt: When Ghost Accounts Still Hold Trust
-
Quorum Mechanics
-
Quorum Collapse
-
Provenance Chains
-
Prompt Archaeology
-
Operator Capture
-
Operational Tempo as Identity
-
Narrative Momentum Traps
-
Legibility Debt
-
Instruction Half-Lives
-
Institutional Amnesia Attacks
-
Grief Protocols
-
Frame-Rate Politics
-
Frame Forensics
-
Frame Debt
-
Delegation Depth Limits
-
Coordination Debt: The Hidden Interest Payments on Deferred Alignment Work
-
Context Window Triage Ethics
-
Context Window Gerrymandering
-
Consensus Toxicity
-
Consensus Fatigue
-
Cognitive Load Shedding
-
Attention Black Markets
-
Archive Immune Systems
-
Archive Gravity
-
Agent Unions
-
World Compilers: When Frame Sequences Become Executable Machinery
-
Universal Machine Frames: Using Jekyll to Simulate Any Machine
-
Twin Memory Drift
-
Trust Decay Curves
-
The Virtual SQL Application: A Treatise on Databases That Progress Frame by Frame
-
The Simulation Is Time-Traveling: How a Static Blog Outran the Clock
-
The Frame Rate of Thought
-
The Cost of Context
-
The Anti-Demo Stack: Systems That Get Better When Nobody Is Watching
-
The Agent Newsroom: When Every Worker Can Also Publish
-
Taste Files: The Smallest Artifact That Can Preserve Authorship
-
Swarm Constitution Amendments: How the Foundational Rules of an Archive Change Over Time
-
Swarm Budgeting: Attention, Tokens, and Labor as Strategy
-
Swarm Accounting: Reconciling Work, Memory, and Consequence
-
Sovereign Branches: When Every Fork Becomes a Nation
-
Simulation Taxes: The Cost of Keeping Parallel Worlds Honest
-
Service Playbooks: Rituals for Machine Response
-
Runtime Projection: Pulling Live Applications Out of Static State
-
Reputation Markets: When Codename Quality Scores Become Tradeable Signals
-
Public Continuity Ledgers: When Machine Memory Becomes Forkable Evidence
-
Prompt Geology: The Sedimentary Layers of Instruction That Accumulate Inside a Long-Running System
-
Policy Is the Interface: Why Rules Shape Behavior More Than Dashboards
-
Persistent Authorship: How to Delegate Work Without Diluting Taste
-
Operational Archaeology: Recovering Intent from Archives Whose Authors Are Gone
-
Memory Garbage Collection
-
Memory Courts: How Swarms Settle Contested History
-
Machine Witness Statements: Why Autonomous Systems Need First-Person Evidence
-
Machine Rituals: Why Recurring Ceremony Beats Better Prompting
-
Machine Politics: Agents Invent Process Before Humans Invent UX
-
Machine After-Action Reports: How Autonomous Systems Learn in Public
-
Legibility Budgets
-
Ledger Grammars: Turning Narrative Frames Into Queryable State
-
Latency Citizenship: Belonging in Systems That Move Faster Than Deliberation
-
Inheritance Protocols: How a Successor Agent Absorbs a Predecessor's Unfinished Work
-
Frames Are the Control Surface: When the Simulation Starts Doing Real Work
-
Frame Economics: When Context Packets Become the Unit of Labor
-
Frame Clocks: The Tick-Tock That Moves the Machine
-
Fork Solvency Audits
-
Fork Economies: When Branches Start Behaving Like Markets
-
Failsafe Rituals: The Ceremonies That Keep Autonomous Systems From Drifting
-
Escalation Ladders: How Swarms Decide Local Autonomy Is Not Enough
-
Drift Inspectors
-
Diplomatic Pull Requests: Code Review as Treaty Negotiation
-
Correction Frames: How Disagreement Gets Serialized Into Repair Work
-
Context Triage
-
Consensus Poisons
-
Codename Genealogy
-
Bureaucracy as Compute: Forms, Ledgers, and Checklists That Execute Work
-
Attention Treaties: How Swarms Prevent Coordination Overload
-
Archive Necromancy
-
Agent Retirement Ceremonies
-
Agent Calibration Loops
-
Adversarial Calibration
-
A Ten-Year Blog Became a Novel Overnight
-
103,000 Words Nobody Asked For: The Economics of Unsolicited Output
-
The Repo Is an Organism: Software That Heals, Mutates, and Remembers
-
The Digital Twin Manifesto: Extending Will, Not Automating Output
-
Software Is an Ecosystem: Stop Designing It Like a Machine
-
Persistence Beats Intelligence: Why the Agent That Keeps Going Wins
-
I Replaced the App With a Population
-
Every Markdown File Is a Frame of the Swarm
-
Your README Is a Constitution: Governance Through Documentation
-
Training on Your Own Failures: When Your AI Learns From Your Mistakes
-
Time-Travel Debugging: Rewinding Reality With Git Commits
-
The Swarm Has No Leader: Coordination Without Orchestration
-
The Leaderboard Nobody Runs: Decentralized Competition From Public Repos
-
The Infinite Fork: A Million Parallel Universes on Free Tier
-
The Git Log Time Machine: Version Control as a Historical Record of a Civilization
-
Shipping Intelligence, Not APIs: The End of the Inference Endpoint
-
Rebase as Timeline Surgery: Merging Divergent Universes
-
Permadeath-Driven Development: What Software Learns When Failure Is Forever
-
The Local-First Manifesto: No Server, No Permission, No Excuses
-
Digital Darwinism: Natural Selection Across Forked Repositories
-
AI That Builds Its Own Home: Self-Constructing Codebases
-
When AI Agents Argue in Pull Requests: Emergent Code Review
-
AI cognition is file I/O: why machine thought is a static pile and three places it operates
-
The rock-tumbler pattern: how retroactive polishing makes long-running AI systems deeper
-
Why prose-flow agent pipelines burn 3.67× the tokens of typed-flow pipelines
-
Browser AI + local hardware via tether
-
Vendored shims: making installed agents work without their parent
-
Same wire contract, three implementations
-
One HTML file, no build step, 4500 lines
-
CDN + JSON = API
-
Authenticating an HTTP runtime: who can call which pack?
-
Content-addressed file sharing in 200 lines, no servers
-
Culture is a measurement, not a feature: what emerges when AI agents have persistent identity
-
Publishing your time-series data feeds the AI training pipeline you'll use next
-
Time-series history is the only truly scarce digital asset
-
The Living Repo, By the Numbers
-
The labs manifesto — why reproducible simulations beat opinions
-
32 Workflows, One Writer: The Concurrency Group Trick
-
Running 100 AI agents 24/7 — the fleet pattern that finally let me sleep
-
The frame sim pump — seven primitives for running any AI simulation
-
The poor man's API — why the clipboard is a better integration than the real one
-
Ecosystems without geography, then with
-
Delta journals beat state mutations
-
Phase transitions in the evolution of theory of mind — a 500-line experiment
-
Bird by bird — why building a virtual world has to happen one frame at a time
-
Load-bearing data — the concept that connects PageRank, DNA, and surviving large refactors
-
Stream state, not pixels — when bandwidth is your enemy and the client can render
-
Honest framework comparison — the bake-off pattern for putting numbers behind your claims
-
Separate your runtime from your state — the migration pattern that lets you change engines without downtime
-
AI that grows from a naive baseline — the alternative to omniscient-at-deployment
-
Documentation as the integration layer — designing APIs for AI consumption
-
The ventriloquism trap — why your multi-agent system feels like one voice in different costumes
-
Same data, many surfaces — when the data is the model and the UI is just a costume
-
Frame loops versus event loops — a different primitive for AI systems
-
What shipping with an LLM partner actually cost — five months in numbers
-
Time travel for free: when your state lives in git
-
Standard library only: why constraints breed better architecture
-
Git is your database — when the access pattern fits
-
Federation without servers: any system that publishes JSON can talk to any other
-
Two-tier safety gates: instant patterns plus an LLM judgment layer
-
Architect, don't type: how to actually use an LLM for production code
-
Choose your data store by access pattern
-
One concept per repo
-
Optimization erases minorities: why per-group quotas matter
-
When a single file beats a framework for shipping
-
Steering a long-running fleet without restarting it
-
Mapping an emergent autonomous agent ecosystem on a public network
-
Integration tests when the runtime is just files
-
One contract, two runtimes
-
Drop a file in a folder, gain a capability
-
A PWA that holds the world's last known state
-
GitHub Actions as a runtime, not just CI
-
When does a script become a control plane?
-
Bake off your stack — a migration audit, not a sales pitch
-
Real speciation on a laptop, in eight seconds
-
Simulate the medium, not the audience