the repetitive task i automated first

every founder has one task that quietly eats the week. mine was posting and scheduling on X. i have a 9-5, so the content i knew i needed to ship kept losing to the eight other things due that day. write the posts, find the slots, remember to actually post them. small, repetitive, and somehow never done.

the trap is trying to do it faster. the real fix is to stop doing it at all, and hand the whole workflow to an agent.

here's the exact method i use, and the two tools i built to run it.

step 1: find the workflow that's costing you

before you automate anything, name the repetitive, time-costly thing. for me it was X. for you it might be:

• scheduling and posting content
• adding subtitles to every video
• turning a raw demo into an animated clip
• writing release notes, changelogs, cold emails

the test: does it repeat every week, follow roughly the same steps each time, and drain hours you'd rather spend building? if yes, it's a candidate to automate.

step 2: structure it the ICM way

the method that made this click for me is the interpretable context methodology (ICM) by jake van clief. it's open source (MIT): github.com/RinDig/Interpretable-Context-Methodology-ICM-

the core idea is almost too simple: the filesystem is the harness. you don't need crewai or langchain or a multi-agent framework. if the prompt and context for each step already live as markdown files in a well-organized folder, one orchestrating agent can just read the right file at the right moment.

the philosophy, the parts that stuck with me:

• one stage, one job. the old unix principle. each step does exactly one thing.
• plain text is the interface. markdown and json between steps. no binary, no black box.
• every output is an edit surface. the agent writes a file at each stage, and you can read it, fix it, and save it before the next stage runs.
• configure the factory, not the product. set the workspace up once, then run it over and over with different inputs.
• layered context. each stage loads only what it needs, roughly 2 to 8k tokens, instead of one 40k-token mega-prompt.

that last one is the trick to reliability. ICM splits context into five layers:

• layer 0, CLAUDE.md: where am i? (who the agent is, the rules)
• layer 1, CONTEXT.md at the root: where do i go next? (the pipeline map)
• layer 2, CONTEXT.md in each stage: what do i do here?
• layer 3, reference files: what rules apply? (voice guides, brand specs)
• layer 4, working files: what am i working with? (this run's artifacts)

in practice it's just folders. a content pipeline looks like this:

my-workflow/
  CLAUDE.md                    layer 0: who i am, the rules
  CONTEXT.md                   layer 1: the pipeline + routing
  stages/
    01-research/CONTEXT.md     what to gather
    02-script/CONTEXT.md       how to write it
    03-produce/CONTEXT.md      how to build it
    04-verify/CONTEXT.md       how to check it
  reference/                   layer 3: voice + brand rules
  runs/
    2026-07-27-this-post/      layer 4: this run's files
      01-research.md
      02-script.md
      03-produce.md

each stage's CONTEXT.md is tiny and says three things: inputs (which files to load), process (what to do), outputs (what to write, and where). the agent walks the folders in order. and because each stage output is its own file, if stage 2 needs a rewrite but stage 1 was fine, you re-run only stage 2. it's incremental compilation, but for content.

step 3: build the tools that let you just talk

structure gets you a repeatable pipeline. the last mile is making it something you trigger by talking, not clicking through steps.

for my X problem i built two things:

• vibedraft is an X writing OS. it trains on my last 500 tweets, drafts in my actual voice, and queues posts into peak slots. the drafting-and-scheduling brain.
• x-poster is a CLI, an MCP server, and a plugin. it lets an agent post to X directly, from a terminal or from claude desktop. the hands.

now the whole thing is a conversation. i open a terminal or claude desktop and say "draft this week's posts and schedule them," and the agent runs the ICM pipeline, writes in my voice, and x-poster drops them into the queue. i skim the files, fix what's off, and it ships. the task that used to lose to my 9-5 every single week now takes a few minutes of talking.

the takeaway

1. name the weekly task that drains you.
2. break it into stages, each a folder with a tiny CONTEXT.md (inputs, process, outputs).
3. wire the last mile so you trigger it by talking to an agent instead of doing the steps yourself.

that's the whole move. stop doing the repetitive thing faster, and turn it into a factory you configure once and run by conversation.

more next week. real numbers, win or loss.

ricky