递归漂移
用 AI 构建的非线性方法。
递归漂移。
用 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.
状态
带反馈循环的状态机
a state machine with feedback loops. enter any state the work demands. leave when the state's job is done.
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.
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.
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.
stop mid-flow. question assumptions. redirect. this is the state most people skip, and it's the one that prevents the most wasted work.
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.
plant breadcrumbs and forward-references for future loops. seeds are one-sentence asides dropped into current content that tease future work. they create pull.
递归
输出反馈为输入
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 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.
这不是什么
它的不同之处
悖论
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.