Recursive Drift

The non-linear method for building with AI.

⌄

recursive drift.

the non-linear method for building with AI.

this isn't a framework you follow. it's a pattern you recognize after the fact. when you look at what you built and realize the plan rewrote itself three times during execution, the documentation documented itself, and the content about the system became part of the system.

six modes. no fixed order. you enter whichever one the work demands. each pass compounds on the last. the output of one loop becomes the context for the next.

The States

A state machine with feedback loops

a state machine with feedback loops. enter any state the work demands. leave when the state's job is done.

freefallexplore

explore without structure. let ideas collide. no outline, no destination. this is where unexpected connections surface. GTM campaigns next to avatar sprites next to newsletter drafts. the mess is the point.

in practice:the idea bank captures freefall output. unstructured sparks parked across domains with no obligation to ship.

plancrystallize

crystallize freefall into parallel tracks. multi-plan, not single-plan. plans are living documents. they rewrite themselves during execution as the build reveals what the plan got wrong.

in practice:the weekend three-site launch plan replaced a previous plan mid-execution. same destination, restructured after the build revealed the original architecture wouldn't scale.

builddelegate

delegate to AI with full context and ship fast. context is the differentiator. skill files, voice playbooks, partner research, prior outputs all loaded before a single line gets written.

in practice:42 invokable skills, each one a context payload that turns a slash command into a full workflow. the build runs because the context was set up first.

breakredirect

stop mid-flow. question assumptions. redirect. this is the state most people skip, and it's the one that prevents the most wasted work.

in practice:the content OS meta post came from breaking mid-workflow to ask why the process felt slow. then rebuilding the process and documenting the rebuild as the content itself.

askinterrogate

interrogate the system. ask the AI about itself. ask the plan about the plan. this isn't prompting. it's using the system's self-awareness as a debugging tool.

in practice:the /arc page was built by asking the system to describe itself. the page explains the methodology by interrogating it.

seedplant

plant breadcrumbs and forward-references for future loops. seeds are one-sentence asides dropped into current content that tease future work. they create pull.

in practice:the screen teaser post includes internal notes: "comment 2 seeds the Mac Mini arc without naming it. full reveal comes later."

Recursive

Output feeds back as input

output feeds back as input. that's the core mechanic.

this isn't CS recursion. it's system-level self-reference. the skill-play command was run on itself for its first execution. the post about the command that creates posts about skills was written by running that command on itself. recursion isn't a trick. it's a design constraint that forces generality.

when your documentation tool has to document itself, you're forced to make it general enough to document anything.

the website explains the system that built the websitethe /about page says: "every skill, every post, every campaign runs through a single codebase. the site you're on right now is the proof of work." the page is output. the system is input. they're the same thing.

plans rewrite themselves during executiona launch plan reached version three before shipping. each rewrite didn't start from scratch. it started from what the previous attempt revealed. the failure was the input.

content becomes infrastructureposts about the content OS led to codifying those workflows as reusable skills. the post was the prototype. the skill was the production version.

skills produce content that documents the skillsevery skill execution is a potential content draft. the system documents itself because it's already running when you need the documentation.

the system gets denser over time without getting heavier. each pass adds context that makes the next pass faster. the 42nd skill is easier to build than the 1st because 41 skills worth of patterns already exist as input.

What This Is Not

not vibe codingfreefall has intent. you explore to find connections, not to avoid planning. freefall without eventual crystallization is just procrastination.

not prompt engineeringthis isn't about crafting the perfect prompt. prompts are single-use. recursive drift builds context payloads that persist and compound across every interaction.

not "let AI do everything"the human decides when to switch states. the human recognizes when break is needed. AI executes within states. the human navigates between them.

not linearno phase 1 → phase 2 pipeline. the sequence is determined by the work, not by the method.

not a productivity hackthis isn't about shipping faster (though it does). it's about shipping things that compound. each output makes the next build easier, the next content more grounded, the next plan more informed.

How It Differs

from prompt engineering:those optimize a single interaction. recursive drift optimizes across interactions. the unit of work isn't a prompt. it's a loop.

from linear build frameworks:those assume the plan survives execution. recursive drift assumes the plan will rewrite itself and builds that rewriting into the method.

from "building in public":building in public treats the build as content source material. recursive drift treats the build and the content as the same artifact.

from agent orchestration:those automate the loop. recursive drift keeps the human in the loop as the state-switcher. the AI doesn't decide when to break or seed. you do.

The Paradox

an unstructured process that produces structured output.

no fixed order. no required sequence. no checklist. and yet: 42 skills, 4 voice playbooks, 3 websites, 93 content files, 15 proprietary scripts, a progression engine, an avatar system, and an IP registry. all from the same recursive loop.

the structure emerges from the recursion. each pass adds a little more form. freefall produces raw ideas. plan gives them shape. build makes them real. break prevents drift. ask reveals what's missing. seed creates pull for the next loop.

the output is structured because the loop ran enough times. not because the process was.

if a system can't describe itself, it's not general enough.

this page was written by the method it documents. freefall produced the concept. plan structured the phases. build delegated the writing. break questioned the name. ask interrogated what made it different. seed planted forward-references before this page existed.

See It Running

the field guide →recursive drift applied to testing new AI features the arc →where this started. plumber, SDR, GTM engineer the log →daily output from the loop the blog →long-form content the system produced the API →endpoints, schemas, live data

← back to about