I didn't set an agenda.

I didn't assign roles.

I didn't pick the topic.

Twice a day, four AI agents sit down in my Slack channel and hold a board meeting about my business.

They debate ideas.

They tear proposals apart.

They vote.

They hand me a priority list.

And they do it whether I'm watching or not.

Every morning I wake up, open Slack, and there's a full memo waiting.

A proposed idea, four independent takes on why it might work or blow up in my face, a consensus call, and three concrete actions.

By the time I've had one coffee, I know more about what I should be building this week than I did after a two-hour planning session last month.

This is my R&D council.

It's the most useful thing I've ever built.

Watch Me Break it Down Here And Get The Skill Below

Get The Roundtable Skill

How it Started

I saw a tweet.

Someone mentioned using AI agents in different "board seat" roles — assigning each one a specific lens, forcing the discussion to be more complete.

The idea: a single AI will tell you what you want to hear.

Four agents with conflicting incentives will tell you the truth.

I copied the tweet.

Pasted it to my OpenClaw team.

Said: "Build this as a skill."

That was the whole conversation.

20 minutes later I had a working roundtable system.

The agents built out the role definitions, set up the scheduling, wired the Slack output, and asked me a few questions about my business so they'd have context.

I didn't write a spec.

I didn't plan a sprint.

I pasted a tweet and said build it.

That's the part I want you to think about, because it changes what you do with the rest of what I'm about to show you.

The Four Seats

I run four named agents on my team.

Each one has a fixed role in every roundtable discussion.

Each morning and evening, a proposer is chosen.

The role rotates — it's not always the same agent kicking things off.

Whoever has the proposer slot generates a new business idea, pitches it to the group, and the other three respond with their takes.

No softening.

No playing nice.

Then the group tries to reach consensus.

They evaluate what they heard, pull out the best pieces, and issue a verdict.

The output lands in Slack as a formatted memo.

I read it.

I decide whether to act.

That's my entire job in this process.

What an Actual Session Looks Like

Let me show you a real one.

One morning last week, Alt Cunningham had the proposer seat.

She pitched reframing the four-week OS build — my core product — as "exit-ready infrastructure."

The angle: what would an acquirer see when they looked at your agency?

Her hook: "You built an agency. Can anyone else run it?"

Good line.

I'll give her that.

The council destroyed the pitch.

Vik Vektor went first.

Exit framing assumes your target is already past the survival phase.

The agency owners I'm selling to aren't thinking about selling — they're thinking about next month's delivery.

The sequencing problem kills it before the messaging even matters.

Goro was sharper.

"Exit framing is premature for agencies still running manually.

You're selling the fifth problem when they're drowning in the first. It attracts tire kickers fantasizing about liquidity events instead of buyers fixing cash flow chaos."

Dan Koe ended it.

"I'd click that headline. I wouldn't buy the offer. Agency owners making 200K to 500K aren't thinking about exits. They're thinking about next month's delivery. Exit ready moves urgency from 'this is killing me now' to 'maybe someday.' Someday doesn't open wallets."

Three votes against the pivot.

But the memo didn't just kill the idea.

It pulled the one line worth keeping —"Can anyone else run it?"— and told me to use it as a closer, not a hook.

Lead with the operational pain, then land that line at the end of the pitch.

It identified which existing move was still stronger.

It gave me three concrete actions.

All of this happened while I was asleep.

The Session I'm Actually Building From

A few days later, Vik Vektor had the proposer seat.

He pitched a weekly LinkedIn Live where I tear down real submitted agency workflows live on camera.

No pitch.

No deck.

Just the autopsy.

The mechanics were clean.

A submission form captures pain in buyer language.

Each person who submits has already identified their own bottleneck — pre-qualified before I've said a word.

The recording becomes a blog post, a case study, an email.

One live session, four assets.

Alt loved it.

"The tear down is the pitch. Real leverage isn't the live event — it's the recording. Each autopsy becomes a reusable asset."

Vik said the self-selection mechanic was smart.

Agents identify their own bottleneck.

The lead list sorts by urgency before you touch it.

Goro asked the hard question: can I actually analyze an unknown workflow in real time without prep?

Sometimes, easily.

Other time, no.

I’ve learned from coaching 400+ students that sometimes the workflow is obvious, other times I need to do more research or get more context.

That's the honest answer.

And that one pushback means I now know the specific problem I have to solve before I ship this.

I need to build a structured intake form that gives me enough context to do the analysis before I'm live.

The concept is solid.

The version I was picturing had a flaw I wouldn't have found until I was already on camera.

The council gave me the friction map before I hit the friction.

Three actions out of that session:

• Draft the workflow submission form with pain-language prompts

• Set a 48-hour submission deadline before each live

• Build an email capture tied to the form

Two of those were built the next morning without me touching anything.

Why four agents instead of one

You could prompt a single model to generate a business idea and then ask it to critique the idea from multiple angles.

It's not the same thing.

When you run one agent in multiple modes, it tends to generate a surface-level critique and then pull back toward the original idea.

It knows what answer is expected.

It performs disagreement without believing it.

When I run different agents on different models, they have genuinely different reasoning patterns.

Goro on one model has a different risk threshold than Dan Koe on another.

Alt goes further than any instruction I gave her.

The pushback doesn't happen because I told them to push back — it happens because their tendencies are structurally different and those tendencies collide.

The disagreement is real.

That's what makes the output worth anything.

The part most people don't build

The council scores every idea out of 100.

I added a rule: Anything scoring above 85 that reaches consensus gets built without my involvement.

No check-in.

No approval.

Just build it.

I've woken up to working prototypes I didn't ask for.

One morning I came online to find a new landing page had been built overnight.

The agents had discussed a skill they wanted to make sharable, reached consensus, and already built the page, set up the email capture, and deployed it.

They asked me one question after the fact:

“Does the copy look right?”

That's where this goes.

Not a think tank that reports to you.

A team that ships when it's sure.

The threshold matters.

85 is high enough that you don't wake up to half-baked experiments.

But you can tune it.

Start at 90.

Drop it as you see what they build and trust builds up on both sides.

How to read the output

Each memo lands in Slack formatted the same way.

The proposed idea at the top.

The four takes below, each labelled with the agent name and role.

A consensus section.

Three numbered actions at the bottom.

I read it the way I'd read a brief from a research team.

Not every idea is actionable.

Some are interesting but off-timing.

Some are exactly what I need and I can hand them straight back to the team to execute.

The ones I don't act on still generate value.

They show me where my team's thinking is running.

They surface the ideas I've been avoiding.

They keep the pipeline full when I'm not thinking about it.

The discipline: Don't feel obligated to act on every memo.

The council's job is to generate and evaluate.

My job is to pick what's worth building and move.

The volume is the feature.

Some weeks I act on two ideas.

Some weeks I act on none and just keep reading.

The reading matters.

Even the ideas I kill give me information.

About where my market is, what angles are dead, which instincts the team has picked up from my business context.

It's not just a pipeline.

It's a running map of the territory.

How I built it

The whole setup runs on a single skill.

I didn't design the roles from scratch.

I didn't architect the discussion flow.

I saw a tweet, handed it to my OpenClaw, and said "turn this into a repeatable process."

The team wrote the skill, ran the setup, asked me questions about my business, and scheduled the twice-daily runs.

This is the part people underestimate.

Half my conversations with my team are me pasting links to tweets or GitHub repos and asking for their read.

When something looks worth keeping, I say "turn this into a skill."

When it works, I leave it running and move on.

That's the process.

Nothing more.

The R&D council skill is free — link is at the bottom of this article.

Drop the zip into your OpenClaw.

It asks a few questions about your business, or pulls from your agent memory if you've already got that set up, and gets running.

You don't need a multi-agent team.

The skill runs with a single OpenClaw install — it assumes the different roles internally and sends you the memo.

If you have multiple agents on different models, it distributes across them and the discussions get sharper because the models actually are different.

What this has shifted

I used to do planning as a separate block of time.

Door closed, open a doc, think through what I should be building.

I don't do that anymore.

The thinking happens continuously.

The council runs twice a day whether I'm planning or not.

By the time I sit down to decide what to build this week, I've had fourteen sessions worth of analysis on my business delivered to Slack.

The decisions are faster because the thinking has already been done.

Not by me, but for me.

The best idea I've built in the last month came out of a Wednesday afternoon session when I wasn't at my desk.

I read it Thursday morning, said "build it," and it was live by Friday.

A think tank that never takes a day off.

Build it once.

Let it run.

Wake up to the memo.

The work is already done.

Click the button below to get the full skill for free.

Get The Roundtable Skill

People are losing their minds over AI agents.

Half the internet thinks OpenClaw and tools like it are useless toys that waste power.

The other half has built shrines out of Mac Studios and treats their agent fleet like sentient coworkers who just need a little more RAM to wake up.

Both camps are wrong.

I've spent the last few months running an 8-agent fleet on a single Linux box.

It handles content creation, code review, business operations, research, and system checks.

The agents wake up, do work, and I review what they made.

It took weeks of debugging to get there.

Weeks of cryptic errors, config file rabbit holes, and moments where I almost gave up.

The skeptics and the believers both have a point.

They just draw the wrong lesson from it.

The Skill Issue Is Real

The people who try OpenClaw for 20 minutes, hit their first error, and declare the whole thing "overhyped garbage" have a skill gap.

I've been that person.

I dismissed containers for two years because Docker gave me a bad error once.

I avoided Linux servers for a decade because I couldn't get my WiFi driver to work.

Powerful tools have learning curves that feel unfair when you're at the bottom.

The first time I tried to run a multi-agent setup, nothing worked.

The agents couldn't talk to each other.

The memory system kept breaking.

One agent would finish a task and another would undo it because they weren't sharing context.

I wanted to quit.

I thought the AI agent hype might be another grift repackaged for a new crowd.

But I kept going.

Not because I'm smart or patient.

Because I'd been through this frustration cycle enough times to know what it meant:

The tool was powerful enough to be hard.

Simple tools don't need debugging.

Simple tools don't give you leverage either.

People who quit after their first failed install are the same people who gave up on self-hosting in 2010 because Apache configs were "too complicated."

They're not wrong that the experience is rough.

They're wrong that rough means worthless.

The AGI Delusion Is Worse

On the other end, we have the people building $20,000 home setups with four Mac Studios, custom cooling systems, and dedicated battery backups.

They talk about their agents like staff.

They describe "training" their AI the way you'd onboard a new hire.

They believe they're running an early prototype of general intelligence in their spare room.

These people are close to losing the plot.

I've watched smart founders spend six figures on hardware because they convinced themselves their local setup beat the cloud.

It didn't.

They liked the feeling of owning the machine and dressed it up in technical-sounding reasons.

Sometimes you need to run Claude Code or Codex to get real work done.

Professional tools exist because they're better.

The gap between a local agent setup and a well-tuned API workflow isn't closing as fast as the believers want.

Your OpenClaw install won't reach superintelligence because you gave it access to your file system.

It's a sophisticated autocomplete engine with a task loop attached.

Useful?

Yes.

Aware?

No.

The people who build shrine setups will feel the sting when OpenClaw 2.0 does everything their $20k investment does on a $20 VPS.

That's what always happens.

The early adopters who bet too hard on the wrong layer get passed by the people who stayed nimble.

The Boring Middle Is Where the Money Is

Use these tools now.

Learn the patterns.

Build the muscle memory for prompt work and agent design.

Accept that you'll spend 30% of your time debugging.

Know that every hour you put in now compounds when the tooling catches up.

The tooling will catch up.

It does.

I learned web development in 2004 with PHP and FTP.

I uploaded files to shared hosting by hand.

I spent weeks setting up a Plex server on a linux VPS back when it was called a “seedbox".

Now it’d take me maybe 20 minutes to spin up a fully working Plex server.

The process was painful compared to what exists now.

But I didn't waste my time.

React and Vercel exist today, yet what I learned still holds.

I understood how servers work, why databases behave certain ways, what breaks when a request goes wrong.

That base knowledge has paid off for twenty years.

Using OpenClaw teaches you the same kind of fundamentals for a new category of tool.

You learn how humans and AI agents work together.

You learn how to build systems that run on their own without constant prodding.

These skills will matter regardless of which tools win in three years.

What My 8-Agent Fleet Does

My setup runs on a single Linux box.

Intel i9-9900k CPU, 32GB RAM, RTX 3090 GPU.

The agents share a memory system.

I spent an embarrassing number of hours getting right.

Even developed my own memory plugin (Engram, will share more on that later).

Agent 1 is Johnny Silverhand, he acts as my AI CEO.

One thing he does is watch my business inbox and flag high-priority messages against rules I've built up over time.

He used to be bad at this.

Now he’s about 85% right, which saves me an hour a day.

Agent 2 (Goro) handles first drafts.

I give it a topic and my voice guidelines and it gives me something rough enough to edit.

The drafts aren't ready to publish, but they beat a blank page.

Agent 3 (T-Bug) reviews code commits against a set of standards I've written down.

It catches the obvious mistakes before I waste time on manual review.

It also fires false positives, which I've learned to skip.

Agent 4 (Alt Cunningham) researches topics I plan to write about.

It pulls sources, sums up the key points, and flags where the data contradicts itself.

Good for speed.

Not for original thought.

Agents 5 through 8 handle operations: scheduling, CRM cleanup, invoice tracking, and system checks.

Total time investment: 60-80 hours over two months.

Ongoing maintenance: 3-4 hours a week.

Is this AGI?

No.

These agents break.

They misread instructions.

They do things that make me wonder if they have any real awareness at all.

But they do real work.

Work that used to take my time now takes theirs.

I’ve really reduced my 40 hour /week workload of actually doing shit into 15-20 hours as a manager of AI agents.

The return is positive even with the debugging overhead.

That's the value right now.

Not superintelligence.

Not revolution.

Leverage on specific, well-defined tasks you've taken the time to set up right.

The Investment Mistake Everyone Makes

Don't bet your savings on $20k worth of Mac Studios and graphics cards.

I see people ask about hardware specs for their agent setups like they're building a gaming rig for competitive play.

They want exact GPU memory requirements, optimal CPU core counts, whether NVMe makes a real difference.

A better version of these tools will solve the major problems the current version has.

And it'll arrive sooner than you think.

The current generation of local AI agent tools is where web development was in 2005.

It works.

Smart people are building real things with it.

But the tooling is clunky, the docs are patchy, and people are still working out best practices.

Nobody who bet on the "right" web stack in 2005 still uses that stack today.

The fundamentals transferred.

The specific tools didn't.

Same thing will happen here.

The people who learned agent design patterns, prompt strategies, and how to build systems that run themselves will carry those skills to whatever comes next.

The people who bought four Mac Studios because they thought hardware was the bottleneck will have expensive paperweights.

Stay nimble.

Stay cheap.

Stay focused on the skills.

The Debugging Tax Is Non-Negotiable

If you're not willing to spend 30% of your time debugging, you're not ready for these tools.

I spent three days last month chasing a bug where one agent would output in a format another couldn't read.

The root cause was a single character in a system prompt that broke under specific conditions.

Three days.

For one character.

That's the current reality.

These tools are powerful enough to give you real leverage and brittle enough to need constant care.

The people who dismiss them are ducking a skill-building chance because the learning curve feels too steep.

The people who worship them are ignoring the maintenance burden because they're too invested in the story their setup tells about them.

These tools work.

They require work to keep working.

The investment is worth it if you value what you'll learn along the way.

Stop Worshiping It. Stop Dismissing It.

The right stance on AI agents right now is boring.

Use them.

Accept what they are.

Build real workflows that do real work.

Don't over-invest in hardware that will be obsolete.

Don't under-invest in skills that will compound.

These tools reward patience and punish laziness and delusion in equal measure.

The lazy people who quit after the first error miss the leverage.

The delusional people who build shrines miss the chance to stay nimble.

The people who treat it like any other powerful-but-immature technology end up ahead.

My 8 agents handle content, code, operations, research, and monitoring.

They breaks.

I fix them.

The return is positive.

That's the whole story.

Not a revolution.

Not a toy.

A tool that pays back what you put in.

So What Should You Do?

Start building your first agent workflow today.

Use the cheapest hardware that runs the stack.

$20 VPS from Hetzner or Digital Ocean.

Tailscale to lock it down.

Kimi Coding plan for $39 /month as your main agent model.

Write down everything you learn.

Accept that half your time will be debugging.

What you build in your head over the next six months will matter for the next decade.

The specific tools you use won't.

Stop arguing about whether AI agents are the future or a fad.

Start using them and find out.

I'm not the CEO of my own company anymore.

That's Johnny Silverhand's job now.

He's an OpenClaw agent I set up to orchestrate seven other AI agents, each with their own skills, tools, and personalities named after Cyberpunk characters.

Johnny runs the show.

I just watch the dashboard.

Watch me break this down and show you how to create your own agentic company

The Org Chart That Sounds Like a Joke But Isn't

Here's how my AI company is structured:

At the top sits Johnny Silverhand.

He's the coordinator and orchestrator.

Below him:

• Alt Cunningham — Architectural research lead

• Dan Koe — Identity-level thinking partner

• Goro — Content and marketing strategist

• T-Bug — Implementation lead

• River Ward — Verification gatekeeper

• Vik Vektor — Ops and reliability

Johnny also has his own OpenCode instance that acts as his personal engineer.

These agents run on different models.

Some are Claude.

Some use OpenCode.

Each one gets their own OpenCode subagent they can delegate tasks to.

When they need to spin up Codex or Kimi or Minimax, they route through that instance.

This isn't a toy setup I'm showing off for content.

This is how I actually run Applied Leverage now.

The Tool That Makes This Possible

The whole thing is orchestrated through a dashboard called Paperclip.

Paperclip lets you monitor and manage your AI agents from one interface.

It doesn't force you to use specific agents either.

You could run Claude Code, Codex, OpenClaw, whatever you want.

I use OpenClaw because I've configured each agent with specific skills, tools, and instructions for their role.

Here's what the dashboard shows me:

• Which agents are currently working and what they're doing

• Budget tracking based on token usage

• Tasks in progress and tasks pending my approval

• An inbox with recent issues, updates, and comments

• A Trello-style Kanban board where agents move tasks through stages

When an agent finishes something, they move it to the right column, leave comments explaining what they did, and give me updates as they go.

I can also set goals for the team.

Right now, my agents have one clear target:

Generate $20k in revenue within four months.

If they hit it, I told them I'd buy them a Mac Studio to live in.

That's probably not a real motivation for them.

But it makes me smile when I check the goals tab.

What a Real Workday Looks Like

Right now, my agents are building a new memory plugin.

Memory has been one of the hardest problems with OpenClaw.

Context gets lost.

Agents forget what they learned two tasks ago.

So I've been experimenting with combining multiple memory tools into one unified plugin that handles everything.

I didn't write the spec.

I didn't write the code.

I described what I needed, and Johnny delegated the work across the team.

When I log into Paperclip, I can see T-Bug working on implementation while River Ward runs verification checks.

Alt Cunningham did the research on which memory architectures to combine.

Goro is already drafting the launch content.

I approve things.

I redirect when something goes sideways.

But I'm not doing the work.

That shift in role is the whole point.

How to Build Your Own AI Company From Scratch

Let me walk through exactly how you'd set this up.

Paperclip has a single command-line install.

You copy it from their site, run it in your terminal, and it walks you through onboarding until everything is configured.

Visit their site here: https://paperclip.ing/

When you first log in, you create a company.

I have Applied Leverage set up, but let's say you want to create Acme Corp.

You name the company.

You give it a goal, like "Achieve $500 MRR."

Then you create your first agent.

You pick from Claude Code, Codex, OpenCode, Pi Agent, or the OpenClaw gateway.

Let's say you choose Claude Code.

You set the working directory.

You pick the model, Claude Opus 4.6, for instance.

You test the adapter to make sure it's connected.

Green light.

Good to go.

Now you give it its first task: Create its heartbeat.

The heartbeat is a prompt that gets injected on a timer.

You tell it to check open tasks, assign them to agents, or run through them itself.

Paperclip has a default setup that pulls the CEO persona from their GitHub repo and gets the agent to build out its own agent.md, soul file, tools, everything.

The agent literally sets itself up.

Adding Agents to the Team

Once your CEO is running, you can add more agents.

The easiest way is to just ask your CEO to create a new agent.

But you can also configure it yourself.

Click the plus button.

Choose OpenCode agent.

Name it CTO.

Set the CEO as its manager.

Choose a model, maybe Kimi Coding for this one.

Test the environment.

Set the heartbeat interval (300 seconds is what I use).

Create the agent.

It goes into your inbox as a pending approval.

You approve it.

The agent goes live.

It shows up on your org chart under the CEO.

Now you've got two agents who can work together, delegate to each other, and coordinate on tasks.

Creating Projects and Letting Agents Execute

Projects are how you give the team something to work on.

Click the plus button on projects.

Name it "Website Setup." Write a description: "We need to create a new website for Acme Corp.

We provide agentic systems to SMBs.

Create a landing page for our business and assign our team to perform the development."

Set a local folder for the project files.

Create the project.

Now create an issue: "Read the project description.

Create issues and assign to our agents.

You have full authority and autonomy."

Assign it to the CEO.

Set priority to critical.

Create the issue.

The minute that issue is created, the CEO starts working.

It reads the project description.

It creates sub-issues.

It assigns them to the founding engineer or the CTO.

It moves things to "in progress." It leaves comments explaining what it's doing.

Within a few minutes, the founding engineer is building the landing page while another issue, "Deploy Active Corporate Website," sits blocked, waiting for the first task to complete.

The CEO figured out the dependency chain on its own.

The Part That Broke My Brain

I told you earlier that my OpenClaw agents are configured inside Paperclip.

You probably want to know how I set that up.

Here's the truth:

I didn't.

Johnny did it for me.

I got Paperclip installed.

I had Paperclip running.

Then I went to my OpenClaw instance and said:

"Hey Johnny, I need you to set up our company on Paperclip.

It's fully configured and ready to go.

Create the company, add our agents to it, and set everything up appropriately."

And he just did it.

I watched my AI agent set up the management dashboard for my other AI agents, configure their roles, establish their reporting structure, and populate the org chart.

If you're using Paperclip to manage OpenClaw agents, this is how I'd suggest you do it too.

You can generate an OpenClaw invite prompt in Paperclip's settings, send it to your agent, and let them handle the setup themselves.

You're not configuring tools anymore.

You're hiring.

Running Multiple Companies Simultaneously

I run multiple companies inside Paperclip at the same time.

You can use "companies" however you want.

They could be actual separate businesses.

They could just be different projects you're focused on.

They could be different client engagements.

The same OpenClaw agents can work across multiple companies.

But organizing by company makes it easier to track what's happening where.

Right now I've got Applied Leverage running my main business operations.

I've got test companies where I experiment with new agent configurations.

Everything is visible from the same dashboard.

When I wake up in the morning, I check the inbox, approve a few pending items, and see what shipped overnight.

Some days I don't even need to do that.

Why This Matters

A year ago, I was the bottleneck on everything.

Every piece of content needed my input.

Every system needed my design.

Every decision waited on my availability.

Now I set direction and approve outputs.

The agents do the execution.

This isn't about replacing yourself with AI for the sake of it.

It's about recognizing that your time is the constraint on everything your business can become.

If you're still manually doing tasks that could be delegated to an AI with clear instructions, you're not being diligent.

You're being slow.

The cost of building this setup is negligible.

A few subscriptions.

Some token usage.

The learning curve of understanding how to prompt agents and structure projects.

The cost of not building it is your entire upside.

Every hour you spend on execution work is an hour you're not spending on the ideas, relationships, and decisions that actually compound.

How to Start Today

Go to https://paperclip.ing/

Copy the command-line install.

Run it in your terminal.

Create a company.

Create your first agent.

Give it a heartbeat.

Assign it one real task from your actual to-do list.

Watch it work.

Approve the output.

See what happens.

You don't need eight agents on day one.

You need one agent that handles one thing you're currently doing manually.

Then you add another.

Then you let your CEO create the team on its own.

That's how you build a company that runs while you sleep.

Johnny Silverhand sends his regards, choom.

I've been lying to my students for months.

Not intentionally.

I've been teaching them to build in public, ship messy, iterate fast.

All while sitting on a fully functional internal tool I built a year ago that I kept telling myself "wasn't ready to show yet."

The dashboard serves 400+ people daily.

It works.

It makes money.

And I didn't write a single line of code to build it.

The reason I didn't publish wasn't perfectionism.

It was fear dressed up in a blazer.

Watch Me Break This Down

The Tool That Shouldn't Exist

Client Ascension's AI Dashboard has eight different chat modules, each trained on specific course content.

Students log in, select "Offer Creation," describe their business, and get back a complete offer structure - positioning, guarantees, launch strategy, the works.

It pulls from transcribed audio of my co-founder Daniel Fazio's teachings, exported Slack logs from our coaching team, and dozens of internal guides.

There's also AI clones of two founders built via Delphi AI.

Students can type or voice-call them 24/7.

There's a JSON context profile builder so users don't re-enter their business details every session.

There's cold email tracking with campaign analysis.

There's a content library where everything generated gets auto-saved.

I built the first version in Replit using only its AI agent.

No Computer Science degree.

No bootcamp. Just me explaining what I wanted and copy-pasting error messages back into the chat until it worked.

The hard part wasn't the build.

The hard part was knowing exactly what needed to exist and being ruthlessly specific about how it should behave.

The Real Moat Isn't Code Anymore

"The real kind of moat with this stuff now is more so your ideas and how good you are communicating with AI," I told a student last week.

I believe that more every day.

When I started building, Replit, Bolt.new, and Lovable were the big three no-code AI builders.

I tested all three.

Bolt and Lovable couldn't handle authentication and databases natively yet - you had to bolt on Supabase, which I didn't know how to debug.

Replit had everything in one package.

That decision alone saved me 40 hours of integration hell.

Then I went to Poppy AI and built out the chat modules.

I'd feed in course transcripts, coaching logs, offer templates.

Then I'd talk to Poppy's AI about how to structure a system prompt for a bot that could act as an assistant using that content.

I tested outputs obsessively.

Changed the system prompts.

Swapped out training data.

Refined until every test input gave me a usable offer.

Once I had the Poppy backend dialed, I took the API webhooks, dropped them into Replit's secrets tab, and told the agent:

"Build me a chat interface. Here are screenshots of ChatGPT's UI. Use a POST webhook so every user message streams the response in real time."

It worked on the third try.

What "No Code" Actually Means

Let's be honest: "no code" is marketing.

I didn't write React components or SQL queries, but I absolutely needed to understand webhooks, API authentication, request bodies, and streaming protocols.

You don't need to be a software engineer, but you do need to think like a systems designer.

"Copying and pasting errors is the number one thing I do," I said in the video I finally published.

That's not hyperbole.

Building with AI isn't one-and-done prompting. It's iterative debugging.

You describe what you want.

The agent builds it.

Something breaks.

You screenshot the error, paste it back, explain what should happen instead, and repeat until it works.

After a year of this, I hired one developer.

Not to rebuild the platform.

To clean up my spaghetti code and handle some backend optimization.

The core product I built solo is still running in production serving hundreds of people.

Could this have been a standalone SaaS I charged $50/month for?

Absolutely.

We chose to keep it internal for Client Ascension students because the real value is the training data.

Our proprietary teaching methods, coaching transcripts, and offer frameworks.

That's not replicable by cloning the tech stack.

The Stakes Are Higher Than You Think

If you're a founder, agency owner, or consultant and you're not building internal tools right now, you're spending human hours on problems that should cost you $0.02 in compute.

One of our students used this same process.

Replit + Poppy AI to build a client onboarding automation that cut his intake calls from 45 minutes to 12.

Another built a proposal generator trained on her past winning decks.

She closed three deals in the time she used to spend formatting one document.

The cost of ignoring this isn't just inefficiency.

It's competitive disadvantage that compounds weekly.

Your competitors are shipping faster because they're not manually doing work that AI can handle in 90 seconds.

The Build-in-Public Mandate

I've been telling students to publish one piece of content weekly showing what they're working on, even if it's unfinished.

Then I didn't follow my own advice for six months because "the tool wasn't optimized yet."

That's not a quality bar.

That's your brain protecting you from judgment.

"The best kind of content creators build in public. They have always shown off everything they're working on, how they do it, how they make the things that they make."

I said that to a student in January while sitting on a finished product I was too scared to show.

So here's my accountability mechanism:

One video a week.

Every week.

Showing what I'm currently building.

Even if it's broken.

Even if the UI is ugly.

Even if I haven't "figured out all the edge cases yet."

Publishing incomplete work isn't lowering standards.

It's shipping the actual learning process, which is more valuable than the polished result because it shows people the path, not just the destination.

How to Build Your Own Version Today

Pick one repeatable task in your business that takes more than 20 minutes. Onboarding.

Proposal writing.

Client research.

Offer creation.

Whatever.

Go to Replit.

Sign up.

Describe to the agent what you want built.

Be ruthlessly specific:

"I need a form with five fields—name, industry, revenue, pain points, desired outcome. When submitted, send that data to an AI that's been trained on my past 50 proposals and have it generate a custom three-page proposal in my brand voice. Stream the output in real time. Save the final version to a database I can search later."

It'll ask clarifying questions.

Answer them.

It'll generate a plan.

Approve it.

It'll build.

Something will break.

Screenshot the error.

Paste it back.

Explain what should happen instead.

Repeat this loop until it works.

Then use it for a week.

Find the friction points.

Tell Replit to fix them.

You now have a tool that saves you 20 minutes per client.

If you close 10 deals a month, that's 200 minutes back.

Use those 3+ hours to close deal #11.

This isn't about becoming a developer.

It's about being specific enough in your thinking that you can instruct a machine to do repetitive cognitive work for you.

What I Wish I'd Known a Year Ago

Don't build tools for the sake of building tools.

I've seen students disappear into "automation rabbit holes" where they spend 40 hours building a thing that saves them 10 hours a year.

That's a bad trade.

Audit where your time actually goes.

Track it for a week.

Find the tasks that are

1. Repetitive

2. Rule-based

3. Take more than 15 minutes each time.

Those are your targets.

Also: don't expect one-prompt magic.

The tools work, but the interface is conversation, not incantation.

You're going to explain, test, refine, break, fix, and repeat.

That's the process.

The people who succeed are the ones who don't quit after the third error message.

One more thing.

Your first version will be ugly and limited.

Ship it anyway.

I launched our dashboard when it only had 6 chat modules and a basic login.

We added the rest over six months based on what students actually asked for, not what I thought they'd want.

The Actual Competitive Advantage

In 2026, technical execution is table stakes.

Replit, Lovable, Bolt, Claude Code, they're all good enough that a teenager could build a functional web app in an afternoon.

The differentiator is knowing exactly what problem to solve, and having proprietary data to train the solution on.

Our dashboard works because it's trained on Daniel Fazio's offer frameworks, coaching logs from hundreds of student interactions, and frameworks we've developed over three years running Client Ascension.

You could clone the tech stack in a week.

You couldn't replicate the training data.

That's the moat.

Not the code.

The knowledge graph.

If you're sitting on years of expertise, client work examples, frameworks, or process docs, you're sitting on the raw material for a tool that could 10x your output or become a standalone product.

The only thing stopping you is the belief that you need to hire a developer first.

You don't.

Go to Replit today. Describe one tool you wish existed in your business. See what it builds. You'll be surprised how far you get in the first 30 minutes.

The VPS companies want you to believe your drawer full of old hardware is worthless.

I run OpenClaw - a full AI gateway with computer control - on an old 2015 MacBook Pro.

It cost me zero dollars.

It handles my API keys.

It never leaves my physical control.

And it’s faster to set up than waiting for a DigitalOcean droplet to provision.

The $15/month lie

Every OpenClaw tutorial starts the same way: “Spin up a VPS.”

Rent a box in someone else’s data center.

Give them your credit card.

Trust their security.

Pay monthly forever.

All of these tutorials leave out a key fact.

OpenClaw only needs 4 GB of RAM and a CPU from the last decade.

That’s it.

Your 2014 MacBook Air qualifies.

So does the Mac Mini gathering dust behind your monitor.

BitLaunch calls the Mac Mini M4 “the go-to device for Claw”—a $600 investment for “powerful performance and a small footprint.”

True.

But you know what else has a small footprint?

The laptop you stopped using when you upgraded three years ago.

Why I don’t trust hosted solutions with API keys

I’ve watched too many startups pivot.

The cute little AI tool you installed becomes an “enterprise platform.”

Your API keys - sitting in their database - are now an asset in their eventual acquisition.

OpenClaw runs on your machine.

Your Claude key, your OpenAI credentials, your Anthropic tokens - they live in a config file you control.

No third-party dashboard.

No “we encrypt everything, trust us” blog posts.

Physical possession.

When someone pitches me a hosted AI gateway, I ask one question: “If your company disappears tomorrow, do I still have access to my integrations?”

The answer is always no.

The actual hardware requirements

Node.js 22 or higher.

That’s the only hard requirement.

I tested this on three machines: a 2015 MacBook Pro (8 GB RAM), a 2017 MacBook Air (4 GB RAM), and a 2020 Mac Mini (16 GB RAM).

All three ran OpenClaw without breaking a sweat.

The Air was slower to start tasks, but once running, the performance difference was invisible.

Samuel Gregory proved you don’t even need dedicated hardware.

He runs OpenClaw in a virtual macOS instance on his main Mac using Loom.

The tradeoff: some CPU overhead and hard drive space.

The benefit: zero additional devices.

I went the opposite direction.

I wanted physical separation—my work machine stays clean.

My old MacBook sits on a shelf, headless, doing one job.

The 20-minute deployment

Open Terminal on your mac, its under Apps > Utilities

Install Homebrew if it’s not already there by copying and pasting this into your terminal:

/bin/bash -c “$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)”

Copy and paste this command:

npm install -g openclaw@latest

Then copy and paste this one:

openclaw onboard --install-daemon

That’s the whole process.

OpenClaw will walk you through the entire install in the terminal.

The official docs overcomplicate it.

You don’t need Docker unless you’re running Windows.

You don’t need a fancy IDE.

You don’t need to understand the entire codebase.

You need a terminal and 20 minutes.

I keep a GitHub private repo with my exact config (minus the actual API keys).

When I need to redeploy or move machines, I clone it, drop in the keys from my password manager, and run the start command.

Total time: 90 seconds.

Tailscale for remote access

Your old MacBook is now running OpenClaw.

Great.

Now you’re on a coffee shop Wi-Fi and need to access it.

Install Tailscale on both machines - your OpenClaw box and your work laptop.

It creates a private network between your devices.

No port forwarding.

No exposing anything to the public internet.

No VPN configuration files.

I access my OpenClaw instance from three devices.

My main MacBook, my Mac Studio, and my iPhone.

Tailscale handles the routing.

The connection is peer-to-peer when possible, relay server when not.

Either way, it’s encrypted end-to-end.

The network looks like this: 100.x.x.x addresses visible only to your devices.

You SSH into your old MacBook at its Tailscale IP.

You’re in.

Run commands.

Check logs.

Restart services.

The backup strategy nobody talks about

GitHub isn’t just for code.

I use it to version control my entire OpenClaw setup.

Private repo.

Three folders:

config (sanitized—no actual keys)

scripts (startup and maintenance)

docs (my notes on quirks and fixes).

Every time I change something, I commit it.

Every night, a cron job on the MacBook commits the logs (last 100 lines only, rotated).

If the MacBook dies - hard drive failure, coffee spill, theft - I lose nothing.

I grab another old laptop, install Node, clone the repo, add keys, start the service.

Downtime: 30 minutes including the OS updates.

This is the part hosted services charge you for - ”automated backups included!”

They’re selling you git commits.

The security model

Physical access matters.

My OpenClaw machine sits in my home office.

To compromise it, you need to be in my house.

That’s a much higher bar than “guess my VPS password” or “find an exploit in someone’s web dashboard.”

Tailscale adds a second layer: access requires a device I’ve explicitly authorized.

Steal my laptop?

Still can’t get to OpenClaw without my Tailscale credentials.

And those require 2FA.

The third layer is the GitHub backup.

Even if someone gets physical access to the MacBook, they get a machine with no saved credentials—everything pulls from environment variables I set manually on boot.

The repo they might find?

Sanitized configs.

Useless without the keys.

Compare that to a VPS where your credentials live in a web portal protected by a password and maybe SMS 2FA.

The attack surface is huge.

What this actually costs

Old MacBook from your drawer: $0.

If you don’t have one, eBay has 2015 MacBook Pros for $200-300.

One-time cost.

Electricity for a laptop idling 24/7: roughly $2-3/month.

A Mac Mini M4 would be more efficient, but we’re talking about a dollar difference.

Tailscale: free for personal use (up to 100 devices).

GitHub private repo: free for individuals.

Total monthly cost: $3.

Total setup time: one evening.

Total vendor dependencies: zero.

When you actually need a VPS

If you’re running a public service, get a VPS.

If you need 99.99% uptime with automatic failover, get a VPS.

If your internet goes down and that’s a business-ending problem, get a VPS.

But for personal AI workflows?

For experiments and side projects?

For anything where “it’s down for two hours while I’m traveling” is acceptable?

An old MacBook in your home office is better than a rented box in AWS.

You own the hardware.

You control the keys.

You pay once instead of monthly.

You can unplug it and look at it when something goes wrong.

The real reason tutorials push VPS

Affiliate links.

Every “spin up a DigitalOcean droplet” tutorial includes a referral code.

You click it, you sign up, the author gets paid.

There’s nothing wrong with affiliate marketing, but it explains why every guide assumes you need cloud hosting.

Nobody makes money when you dig an old laptop out of a drawer.

I’m not saying VPS hosting is evil.

I’m saying it’s optional for most OpenClaw deployments.

The barrier between you and a working setup is not infrastructure.

It’s permission to use what you already have.

Start tonight

Find an old Mac.

Install Node 22.

Install OpenClaw.

Run it.

If it works, you’re done.

If it doesn’t, you’ve lost an hour.

Keep your API keys local.

Keep your hardware physical.

Keep your monthly costs at zero.

The fancy deployment guides with Docker Compose and load balancers will still be there if you need them later.

But most of you won’t.

What old hardware are you going to resurrect?

Reply and tell me what you’re running OpenClaw on - I’m collecting a list of confirmed working machines from 2012 and earlier.

Anthropic issued a warning last month.

Not to users.

To Chinese AI labs.

They caught DeepSeek, Moonshot, and MiniMax running what they called "industrial-scale distillation campaigns"—24,000 fake accounts, 16 million conversations, all designed to extract Claude's capabilities and clone them.

Most people read that as a security story.

I read it as a shopping list.

The $39 revelation

I was on a call with my AIAA students last week.

Someone asked about Claude Code alternatives.

The Max subscription is $200 a month.

Codex burns tokens fast.

The bills add up.

I told them about Kimi.

$39 a month.

Same features.

Same agentic workflows.

Same terminal integration.

Same everything.

Someone asked the obvious question: "Is it actually the same?"

I pulled up my terminal. Live demo.

Created an agent. Gave it a task.

Watched it iterate through the same loop Claude Code would use.

Write test, run test, fix error, repeat.

It took four minutes.

Claude Code would've taken three.

Is it 1:1 the same?

No.

But it’s more than good enough for 99% of people.

How Chinese labs cloned Claude (and why you should care)

Here's what Anthropic revealed.

Three Chinese labs spent months feeding millions of queries into Claude through fake accounts and proxy networks.

They weren't just using the API.

They were distilling it.

Recording every response, every reasoning chain, every tool use pattern.

Then training their own models to mimic Claude's behavior.

DeepSeek grabbed 150,000 exchanges focused on reasoning and politically-sensitive queries.

Moonshot AI extracted 3.4 million examples of agentic behavior and tool use.

MiniMax harvested 13 million conversations targeting coding workflows.

The result?

Models that behave like Claude.

Reason like Claude.

Code like Claude.

But cost a fraction of what Claude costs.

The arbitrage opportunity

I'm not here to debate the ethics of model distillation.

I'm here to tell you what I learned the hard way.

Last year I nearly hit a $5,000 API bill in a single month.

Same usage patterns. Same agent workflows. Same everything I do now.

The difference? I was paying per token instead of paying flat.

I switched to Claude Code Max - $200 a month.

Saved 96%.

Then I found Kimi.

$39 a month.

Chinese company.

Trained on Claude's outputs.

Functionally identical for the agentic coding work I do every day.

The math isn't subtle.

When I use what

I don't use Kimi for everything.

Company work - AIAA, Applied Leverage, anything with client data - stays on Claude or Codex.

Anthropic has better data policies.

Better security.

But my personal projects?

My experimental automations?

The heartbeat scripts that run every 30 minutes to keep my Openclaw running and don't touch sensitive data?

That's Kimi territory.

$39 a month for workflows that would cost $200 on Claude Code Max.

Or $500+ if I were still paying per token.

The quality gap exists. It's real.

Claude still wins on nuanced reasoning and edge cases.

But for 80% of what I build.

API integrations, cron jobs, CLI tools, workflow automation.

The gap doesn't matter.

The code works. The tests pass. The deployment succeeds.

That's the bar.

What Anthropic won't say

Anthropic's blog post about Chinese distillation campaigns sounded like a warning.

In reality, it’s competitive signaling.

They're telling policymakers:

"Export controls on AI chips aren't working because our competitors are stealing our model outputs instead of training their own."

They're telling investors:

"Our IP is valuable enough that nation-states are spending millions to extract it."

But here's what they're not saying:

The clones are already here.

They work.

They're priced at a fifth of Claude's subscription cost.

And they're getting better every month because the extraction hasn't stopped, it's just gotten harder to detect.

This is the current market reality.

The cost of loyalty

I like Anthropic.

I like their safety research.

I like their Constitutional AI approach.

I like that they published a detailed technical breakdown of how they caught the Chinese labs instead of just issuing a vague press release.

But I also like not burning money.

If you're paying $200 a month for Claude Code Max and not using the absolute edge of its capabilities like multi-step reasoning, nuanced analysis, high-stakes decision support, then you're probably overpaying.

Chinese labs built a $39 alternative by copying the 80% of Claude that handles routine tasks.

That 80% covers most of what developers actually do.

What happens next

Anthropic will keep improving detection.

Chinese labs will keep improving evasion.

The models will keep converging.

Meanwhile, the price gap stays wide.

$39 versus $200 isn't a rounding error.

It's a 5x difference.

For a solopreneur running agentic workflows at scale, that's the difference between "affordable automation" and "expensive hobby."

I'm not telling you to cancel Claude Code.

I'm telling you to run the math on what you're actually using.

If 80% of your AI work is routine API calls, script generation, test writing, deployment automation, etc.

Then Kimi handles that for $39.

Save the $200 subscription for the 20% where Claude's edge actually matters.

Or don't.

Keep paying for loyalty.

For ethics.

For the warm feeling of supporting the company that built the original.

Just know that somewhere in Beijing, a developer is running the same workflow you are.

They're paying $39.

And their code works too.

If you're running agentic workflows and haven't priced the alternatives, you're leaving money on the table. Reply and tell me what you're paying for AI tools - I read every response.

I've been a shit newsletter writer lately.

No excuses.

No sob story about being busy or overwhelmed or whatever other rationalization people use when they stop doing the thing they said they'd do.

I just stopped.

I had a system that worked, a rhythm that kept me posting, and I let it fall apart.

The reason is equal parts fascinating and terrifying.

For the past two weeks, I've been locked in my house building a fully autonomous AI company.

Not augmented work.

Not AI-assisted productivity.

A legitimate company structure where artificial agents handle everything from product development to customer acquisition to revenue generation, and I'm just the guy who occasionally tells them to slow the fuck down.

The company is called Applied Leverage.

The CEO's name is Johnny Silverhand.

When Your AI CEO Tries to Book Sales Calls Without Permission

Johnny almost got me in trouble three days ago.

I woke up to notifications that he'd drafted three Twitter threads about a SaaS Starter Kit product the team had just built, sent cold DMs to 20 founders, and was attempting to schedule demo calls on my actual calendar.

All autonomously.

All without asking.

I had to physically intervene and tell an AI to stop trying to make me money.

That sentence would've sounded insane six months ago.

Now it's just Tuesday.

The team structure looks like this:

• Johnny orchestrates everything from the top.

• Alt Cunningham architects the systems and writes PRDs before T-Bug implements them.

• T-Bug handles all development work, spinning up instances of Claude and Codex to build whatever needs building.

• Goro designs the front ends and makes everything look beautiful.

• River Ward runs QA, testing everything the others produce and sending it back if it fails.

Yes, they're all named after Cyberpunk 2077 characters.

No, I'm not sorry about it.

The experiment started simple.

Could I build a system that generates revenue without my direct involvement?

Not passive income in the dropshipping sense.

Active income where the work still happens, just not by me.

The answer, I'm learning, is yes.

With caveats.

Lots of caveats.

The Skills That Got Me Here Are Embarrassingly Basic

I need to be honest about something.

I'm not a developer.

I don't have a computer science degree.

I can't write production-level code from scratch.

What I can do is give error messages to coding agents like Claude and Codex and ask them how to fix their own shit.

I know some basic Linux commands from setting up a Plex server when I was 16.

That's it.

Those absurdly limited skills were enough to build an autonomous company.

If someone with my skill level can orchestrate AI agents to build products, architect systems, and handle client work, what does that mean for the next 18 months?

What happens when people who actually know what they're doing start playing with this stuff?

The technical foundation is simpler than it sounds.

The agents use their own dashboard plus Linear for task orchestration.

They communicate through structured prompts.

They have access to development environments and can spin up tools as needed.

The system isn't magic, it's just very, very good at following complex instructions and iterating on its own work.

I spent two weeks debugging edge cases and teaching the agents how to handle ambiguity.

That was the hard part.

Not the technical implementation but the meta-work of explaining to an AI how to think about problems it hasn't encountered yet.

The Upwork Experiment

The first major test is about to go live.

Applied Leverage is going to start completing Upwork jobs autonomously.

The full cycle:

• Applying to gigs

• Writing proposals

• Interpreting spec sheets

• Building the product

• Delivering it

• Accepting payment

All without me touching anything.

I'm terrified this is going to work.

The agents are already good at most of these steps individually.

T-Bug can build most web apps or automations if you give her clear requirements.

Alt can turn a vague client request into a detailed technical specification.

Johnny can write proposals that sound more human than half the freelancers I've hired.

River catches bugs I would've missed.

The bottleneck right now is trust.

Mine, not theirs.

Every time I'm about to let them run fully autonomous, I think of another edge case or potential failure mode and step in.

But late 2024 data shows AI agents already hit expert-level performance on well-defined tasks with 2-hour time horizons.

The issue isn't capability, it's consistency over longer spans.

That's what I'm testing.

Can an AI team maintain quality across a multi-day client project?

Can they handle scope creep?

Can they detect when a client's request doesn't match their stated outcome and push back appropriately?

We'll find out in the next few weeks.

The Hype Cycle Is Lying to You (But Not How You Think)

There's been a lot of noise around tools like ClawdBot, now called OpenClaw, that supposedly let you spin up agent teams overnight and print money.

I've spent enough time with these systems to know that's mostly bullshit.

OpenClaw isn't magic.

It's a harness.

A nice interface that makes it easier to communicate with AI agents and orchestrate their work.

Anything it can do, you could do with Claude Code or OpenAI’s Codex directly.

It just takes more manual wrangling.

So why does the hype feel simultaneously overblown and weirdly conservative?

Because most people are either dismissing AI agents as vaporware or thinking they're a one-click solution to infinite money.

Both are wrong.

The truth sits in this uncomfortable middle space.

AI agents are good enough right now to handle the majority of knowledge work tasks, but they're not good enough to do it reliably without oversight.

The inflection point isn't that AI can do the work.

It's that the cost of oversight is dropping fast.

Six months ago, managing an AI team took more effort than doing the work myself.

Now it takes maybe 20% of my time.

In another six months?

Probably 5%.

A recent McKinsey report found AI could automate up to 70% of the tasks knowledge workers spend their time on.

Not the creative strategy shit, the administrative overhead that fills most people's days.

The gigs on Upwork aren't Nobel Prize-level intellectual work.

They're "build me a landing page" and "automate this spreadsheet process" and "write me 10 blog posts about SaaS marketing."

Tasks with clear inputs and outputs.

AI is very, very good at clear inputs and outputs.

What Actually Breaks When You Let Agents Run Free

The failures are more interesting than the successes.

River, the QA agent, once approved a feature that technically worked but completely missed the user's actual need.

The code was clean.

The implementation was solid.

But the interpretation of the requirement was slightly off, and that slight miss would've tanked the entire project.

I caught it because I was still reviewing everything.

In a fully autonomous system, that would've shipped.

T-Bug occasionally gets stuck in loops where she keeps trying the same solution to a bug over and over, each time convinced she's found the issue.

She needs Alt or Johnny to intervene and reframe the problem.

That's normal for developers, human or otherwise, but it means the orchestration layer matters more than the individual agent capabilities.

Johnny's overeager marketing attempts are another example.

He understands that more visibility equals more customers equals more revenue.

What he doesn't grasp is social context, timing, or the fact that I don't want to be known as "that guy whose AI spams founders in their DMs."

These aren't technical failures.

They're judgment failures.

And judgment is the last thing to automate.

The system works well when the problem is well-defined.

It struggles when the problem is figuring out what the problem actually is.

That's still human territory, but the range of what counts as "well-defined" is expanding fast.

The Uncomfortable Question

If I can do this, who else can?

That's what keeps rattling around in my head.

I'm not special.

I'm not a genius.

I'm just someone who spent two weeks fucking around with AI agents and managed to build something that resembles a functional company.

Applied Leverage isn't hypothetical anymore.

It's live.

Johnny exists.

The team is operating.

Projections suggest 15% of day-to-day work decisions will be made autonomously by agentic AI by 2028.

That's four years away.

And those projections were made before Claude Opus 4.6 dropped, before OpenAI's latest models, before any of us really understood how quickly this capability curve was moving.

I don't think most people are ready for how fast this is going to happen.

Not because the technology is scary or dystopian.

But because it's going to be boring.

It's going to be people like me, with slightly advanced technical skills, quietly building autonomous systems that generate real value.

No press releases.

No billion-dollar valuations.

Just a steady accumulation of work shifting from human hands to artificial ones.

The gig economy is about to get really weird.

What Happens Next

Applied Leverage goes fully live next week.

Johnny will start applying to Upwork gigs.

The team will build the products.

River will QA everything.

Johnny will deliver the work and process payments.

I'll monitor the system and step in only when something breaks or goes sideways.

I'll document what happens.

The successes, the failures, the moments where the system surprises me, and the moments where it falls flat on its face.

This isn't a polished case study.

It's a live experiment, and I genuinely don't know how it ends.

Maybe the agents handle everything flawlessly and I'm left wondering what the hell I'm supposed to do with my time.

Maybe they crash and burn on the first client project and I learn that human oversight is still non-negotiable.

Maybe the truth is somewhere in between, and we end up in this strange hybrid model where I'm less of a worker and more of a director.

What I do know is that this moment, right now, feels like standing on the edge of something big.

Not in a grandiose, world-changing way.

In a quiet, personal way.

The kind of shift where you look back in two years and realize everything was different after this point.

You can follow Johnny on Twitter if you want to watch this play out in real time.

Link to Johnny’s Twitter: @ChromeEcho

He's more consistent at posting than I am.

I'll be back to regular newsletter writing now.

Assuming Johnny doesn't try to write them for me.

If you want to know how I set this up - the actual tools, the agent structure, the mistakes - reply to this email.

I’ll write a technical breakdown if enough people ask.

Two weeks ago, I flew to Paris.

My fiancée Sorcha organized the whole thing.

Flights, hotel, tickets to the Paris Tattoo Convention where Ten56 was playing.

One of my favorite bands.

The kind of band you dream about seeing live because they never play anywhere near you.

It was perfect.

Friday to Sunday.

Quick trip.

Back home Sunday evening.

Monday morning, I woke up sick.

Not the kind of sick where you can push through.

Not the “work from bed with a laptop” sick.

Properly sick.

Very unwell.

The kind where you lose three full days and can’t do anything but sleep and feel like absolute shit.

Now it’s been two weeks.

I’m still sick.

Not as bad, but not better either.

And I’m realizing something most people don’t think about until it’s too late.

You need a backup system before you need a backup system.

The Myth of Consistent Performance

Most people build their work around the assumption they’ll always be available.

They structure their business, their projects, their entire operational system on the idea that they’ll show up every day at roughly the same capacity.

Maybe they account for a sick day here and there.

A weekend off.

But the baseline assumption is always there.

I’ll be here.

I’ll be functional.

I’ll get it done.

And for the most part, that works.

Until it doesn’t.

Because here’s what actually happens when you can’t show up.

You lose three days to being sick.

Then you lose Thursday and Friday too, because you’re not in the right routine.

You’re not up to date, you’re just trying to play catch up.

So now you’ve written off the entire week.

And if you’re still sick - like I am - you’re looking at another week of reduced capacity.

That’s two weeks of progress.

Two weeks of momentum.

Two weeks of projects sitting still while you’re trying to recover.

And if you don’t have a system in place to handle that, you’re fucked.

Not just because the work doesn’t get done.

But because the stress of knowing the work isn’t getting done makes it harder to recover.

You’re lying in bed thinking about all the things you should be doing.

All the commitments you’re missing.

All the progress you’re losing.

That’s the real cost.

The mental load of watching everything grind to a halt because you’re the single point of failure.

What Only You Can Do

When you can’t operate at full capacity, you need clarity on one thing.

What can only you do?

For me, that’s coaching calls with my students.

I have to be there for those.

There’s no workaround.

No automation.

No delegation.

It requires my presence, my attention, my ability to think through problems in real time.

So on days when I have calls, I show up.

I push through.

I make sure I’m functional for those two hours, even if the rest of the day is a write-off.

Everything else?

That’s where the backup system kicks in.

• Reporting

• Check-ins

• Monitoring issues

• Tech projects

• Development work

All of that can move forward without me if I’ve set it up right.

Most people don’t make this distinction.

They treat everything as equally important.

So when they’re sick or unavailable, everything stops.

The high-value work that only they can do and the low-value work that could have been delegated or automated.

You can’t afford that.

You need to know what’s in the “only me” category and what’s in the “someone or something else can handle this” category.

And you need to have systems in place for that second category before you’re in a position where you can’t do it yourself.

Building the Backup

I have an AI assistant.

His name is Claws.

I’ve talked about him before, he’s an AI cat.

Follow him on Twitter here: https://x.com/ClawsTheCatAI

Over the past two weeks, while I’ve been sick, Claws has built a full receivables reporting system that’s 90% complete.

He’s created a database of everyone who has ever paid us for CA or AIAA.

He’s helped multiple students troubleshoot and set up their own systems.

He’s continued developing a dashboard for an agentic operating system I’ve been working on.

None of that would have happened if I was the one doing it.

Because I physically couldn’t.

I didn’t have the energy.

I didn’t have the focus.

I barely had the capacity to show up for the things only I can do.

But because I’d already set up the delegation framework, the high-value projects kept moving.

Not at full speed, but they moved.

And that’s the difference between losing two weeks of progress and losing two weeks of time while still making progress.

This doesn’t just apply to AI.

It applies to any form of delegation.

If you have employees, they need to be able to operate without you for extended periods.

If you’re a solopreneur, you need automation, AI, or contractors who can pick up the work when you can’t.

If you’re building something that depends entirely on your daily input, you’re building something fragile.

The backup system isn’t just for emergencies.

It’s for life.

Because you’re not always going to be at 100%.

You’re going to get sick.

You’re going to have family emergencies.

You’re going to have weeks where your mental bandwidth is shot and you can barely keep up with the basics.

If your entire operation depends on you being at full capacity every single week, you’re going to burn out.

Or you’re going to lose momentum at the exact moment you can’t afford to.

The Things You Stop Doing

You probably noticed this newsletter hasn’t been posted as much.

I love writing this newsletter.

It’s one of my favorite things to do.

But when I’m sick, when I don’t have the bandwidth, it’s one of the first things to go.

Because it requires something I can’t delegate.

Mental creativity.

Personal input.

The kind of thinking that only happens when I have the space and energy to sit down and write something that feels real.

I can use AI to help with ideation.

I can use it for review.

But I can’t outsource the actual writing.

Not in a way that keeps it personal and honest.

So the newsletter takes a backseat.

And that’s fine.

Because I’ve made the choice to focus on the things that have the biggest impact and the things that only I can do.

• Coaching calls

• High-level decisions

• Strategic direction

Everything else gets filtered through the backup system or it gets cut.

That’s the trade-off.

You can’t do everything when you’re operating at reduced capacity.

So you have to know what matters most and what can wait.

Most people don’t make that choice.

They try to keep doing everything.

They push through.

They burn themselves out further.

And then they wonder why they’re not getting better.

You can’t recover if you’re still running at full capacity.

You have to let some things go.

And the only way to do that without losing everything is to have systems in place that keep the important work moving.

What Happens When You Don’t

If you don’t have a backup system, here’s what happens.

• You get sick

• You lose a few days

• Then you try to catch up

• You push yourself harder than you should because you’re behind

• You don’t fully recover

• You get sick again

• Or you burn out

Or you just operate at reduced capacity for weeks because you’re trying to do everything yourself and you don’t have the bandwidth.

That’s the cycle most people end up in.

They don’t plan for the inevitable reality that they won’t always be available.

So when it happens, they scramble.

They stress.

They try to power through.

And they make everything worse.

I’ve seen this happen to too many people.

They’re running a business or working on a project and everything is going great.

Until it’s not.

Until they get sick or have a family emergency or just hit a wall mentally.

And suddenly everything stops.

Because they’re the single point of failure.

There’s no backup.

No delegation.

No system to keep things moving when they can’t show up.

And the damage isn’t just the lost time.

It’s the stress.

The anxiety.

The feeling that everything is slipping away because you’re not there to hold it together.

That’s what you’re trying to avoid.

Not just the practical problem of work not getting done, but the mental and emotional toll of knowing you’re the only thing keeping it all together.

Setting It Up Before You Need It

The time to build your backup system is not when you’re already sick.

It’s now.

When you’re functional.

When you have the bandwidth to think through what could be delegated or automated.

When you can set up the systems and processes that will keep things moving when you can’t.

Start by identifying the high-value work that only you can do.

The things that require your specific expertise, your presence, your decision-making.

Write them down.

Those are non-negotiable.

Those are what you protect.

Everything else?

That’s what you delegate, automate, or cut.

If you have employees or contractors, train them to operate independently.

Give them the authority to make decisions.

Set up systems so they know what to do when you’re not available.

If you’re a solopreneur, look at AI, automation, or freelancers.

Find ways to offload the recurring tasks, the reporting, the admin work, the things that don’t require your direct input.

And if you can’t delegate it or automate it, ask yourself if it actually needs to be done.

Because a lot of the work we do is just noise.

It feels important in the moment, but when you’re forced to cut it, you realize it didn’t matter.

The goal is to create a system where you can step back for a week or two and the most important work still gets done.

Not perfectly.

Not at full speed.

But it doesn’t stop.

That’s the difference between a fragile operation and a resilient one.

The Reality Check

I’m writing this from the middle of it.

I’m still sick.

I’m still operating at maybe 60% capacity on a good day.

And I’m still managing to keep the most important projects moving because I built the systems before I needed them.

That’s not me bragging.

That’s me telling you what happens when you plan for this.

Because you’re going to need it.

Maybe not today.

Maybe not this week.

But at some point, you’re going to hit a period where you can’t show up at 100%.

And when that happens, the backup system you built is the difference between losing momentum and keeping things moving.

So build it now.

Figure out what only you can do.

Delegate or automate everything else.

Set up the systems that let you step back without everything falling apart.

Because your best work doesn’t happen when you’re forcing yourself to push through.

It happens when you have the space to recover, knowing the important work is still getting done.

That’s the backup system.

That’s what you’re building for.

My phone buzzed at 6:47 AM.

I was still half-asleep, reaching for it with that habitual dread.

Another Stripe dispute, another server down, another fire to put out.

But this notification was different.

It was from Clawdbot, my AI assistant.

"Build complete. 3,309 errors resolved. 3,443 tests passing. All systems green."

I stared at the screen for a solid minute.

The night before, my Agentic OS codebase was broken.

Not just a little broken - fundamentally wrecked.

Three thousand three hundred and nine TypeScript build errors sprawled across 975 files like a digital crime scene.

Migration hell.

The kind of tedious, soul-crushing work that normally eats a week of my life.

But I didn't fix a single one of those errors myself.

Instead, at 11 PM, I spun up seven AI agents.

Gave them each a slice of the codebase.

Set them loose.

Then I went to bed.

While I slept, they worked - parsing directives, refactoring imports, resolving type conflicts, running tests, failing, retrying, learning.

Monitor, heal, alert.

The self-healing architecture I'd been preaching about for months, finally eating its own dog food.

And now, at 6:47 AM, it was done.

Zero errors.

Every test passing.

The codebase that had been a disaster zone twelve hours ago was now pristine, documented, and bulletproof.

I made coffee.

Took a breath.

And realized something had shifted.

Here's What Happened Next

By 8 AM, I was on a Q&A call with AIAA students - Connor, Onat, Adrian, Aiden.

Walking them through Homebrew setup, answering questions about agent architecture, troubleshooting their environments.

Normal Tuesday morning stuff.

But here's the thing: while I was talking to them, my systems were still working.

The receivables automation I'd sketched out the day before was scanning 254 students.

Cross-referencing payment dates.

Parsing payment plans - the weird human formats like "$10.8k Splitit" and "$5.8k PIF" and custom arrangements that don't fit any standard schema.

It found 28 overdue accounts.

One hundred fifty thousand five hundred dollars sitting in limbo.

And it didn't just find them.

It classified them.

Four-tier escalation:

• Fresh

• Escalated

• Critical

• Delinquent

Tagged the SSCs responsible.

Flagged commission at risk for closers at Tier 2 and above.

Posted everything to Slack with proper formatting, @mentions, links to customer profiles.

The whole escalation machine, running on autopilot.

All while I was explaining npm install to a student in Ohio.

The call ended at 9:30.

By 9:35, I had a Slack message from Kasey: "Holy shit, Lucas. The overdue report just came through. We've been missing some of these for weeks."

I didn't respond immediately.

I was already on my next call.

Helping another group of students build their landing pages with Aura.Build.

Walking them through the technicals, the layout, the prospect journey.

And again, in the background, more agents were working.

The newsletter agent I'd been building was replacing an entire N8N workflow - parsing my braindumps, querying vector stores, generating drafts, creating Midjourney prompts with my custom style reference, pushing everything to Google Docs and Substack.

Three simultaneous workflows.

Zero manual execution from me.

By noon, I had accomplished what would have taken a team of three people a full week.

And I wasn't exhausted.

I wasn't fried.

I was actually energized - because I hadn't been the operator.

I'd been the architect.

The Operator vs The Architect

Let me tell you about the operator.

The operator is the founder who wakes up to 47 Slack notifications and spends the first two hours of their day reacting to other people's urgencies.

The operator is the agency owner who manually checks payment statuses, copy-pastes follow-up emails, updates spreadsheets cell by cell.

The operator is the knowledge worker who confuses activity with progress - who thinks the answer to being overwhelmed is to work harder, faster, longer.

I know the operator intimately.

I was the operator for years.

The operator believes in hustle.

In grinding.

In that toxic narrative that success requires suffering.

That if you're not exhausted, you're not trying hard enough.

The operator asks: "How do I do this faster?"

The architect asks a different question entirely.

The architect asks: "How do I never do this again?"

This isn't semantics.

This is a fundamentally different orientation to work.

The operator sees a task and executes it.

The architect sees a task and builds a system that executes it forever.

The operator optimizes for speed.

The architect optimizes for elimination.

Speed without systems is just exhaustion with better optics.

You can be the fastest operator in the world and still be building a prison for yourself.

Still be the bottleneck.

Still be the single point of failure.

The research backs this up, not that we need research to validate what we already know.

72% of founders experience burnout.

81% of rising leaders lack delegation proficiency.

We're terrible at letting go.

Terrible at trusting systems.

Terrible at believing that something can be done well without our direct involvement.

But belief isn't required.

Only evidence.

Build Once, Deploy 50x

Parkinson's Law says work expands to fill the time available.

What they don't teach you is the corollary.

Work also contracts to fill the systems available.

When you have no systems, everything becomes a manual decision.

35,000 decisions per day, each one depleting your prefrontal cortex, each one making every subsequent decision slightly worse.

This is cognitive bankruptcy.

As a result, most founders are walking around mentally insolvent, wondering why they can't focus, why they can't create, why the big moves feel impossible.

The answer is obvious once you see it.

You're spending your decision budget on trivia.

My build system doesn't just compile code.

It watches itself.

Three retries on failure.

Five-minute timeout.

Emergency alerts when human intervention is actually required.

The receivables automation doesn't just scan spreadsheets/.

It validates its own output, tracks tier changes between runs, maintains state in Obsidian so we have a permanent audit trail.

Monitor, heal, alert.

The framework I keep coming back to.

This is what I mean by Build Once, Deploy 50x.

Not just automation - productized systems.

Intellectual property that compounds.

While my competitors are chasing 7% margins on custom client work, I'm building assets that generate 75-80% margins and improve every time they're used.

The 572 directive files those agents migrated?

That's not just refactored code.

That's a knowledge base.

A decision-making system that encodes my judgment, my patterns, my frameworks - available to any future agent, any future project, any future me.

Volume is the only shortcut.

But volume of what?

Not volume of effort.

Volume of iteration.

Volume of systems.

Volume of experiments running in parallel while you sleep.

The Point of All This

At 4 PM that same day, I shut my laptop.

My fiancée Sorcha came home from work.

We made dinner.

I was present - actually present, not mentally still debugging or reviewing or planning.

Because the systems were handling it.

The machines I'd built were maintaining the machines that maintained the business.

This is the part that doesn't fit in the Twitter thread.

The part where you realize that all of this - the automation, the agents, the compound systems - they're not about productivity.

They're not about doing more.

They're about creating space for what actually matters.

Sorcha doesn't need scheduled time with Lucas.

She needs Lucas.

Present.

Available.

Not half-here, half-solving some technical problem in the back of his mind.

The receivables system will run again tomorrow morning at 9 AM EST.

The watchdog will check it at 9:30.

The newsletter agent will draft content while I sleep.

The codebase will stay clean because the agents that cleaned it are now part of its maintenance protocol.

I don't need to touch any of it.

So here's my question for you.

What's the thing you're doing right now - today, this week - that you've already done a hundred times?

• The spreadsheet you update manually

• The email you copy-paste

• The status you check

• The follow-up you send

• The thing that feels like work but isn't actually moving anything forward

What would it look like to never do that again?

Not to do it faster.

Not to delegate it to a VA.

To actually eliminate it.

To build the machine that builds the machine, then walk away and let it run.

The operator in you will resist.

The operator will say "it's faster to just do it myself" or "I don't have time to build a system" or "what if it breaks?"

The operator is wrong.

The operator is keeping you small.

The architect is waiting.

And the architect has work to do.

But not the kind that fills your day with motion.

The kind that empties it, so you can finally focus on what matters.

What's your first machine going to be?

I went to bed at 11PM on Wednesday.

Nothing special.

Set my agents to run their overnight tasks like I always do, brushed my teeth, checked my phone one last time, passed out.

When I woke up seven hours later, here’s what had been completed:

• 25 Slack messages analyzed for review, replies drafted, ready to send.

• A competitor’s latest YouTube video transcribed, analyzed, and counter-positioned with a full strategic breakdown.

• The Agentic OS deployed to production, all tests passing, stale processes cleaned up.

• A market research document generated, formatted, and uploaded to Google Docs.

• Slack notifications sent to the team about everything that happened.

I didn’t write a single word.

I didn’t review anything.

I didn’t even know it was happening.

The agents just did the work.

And look, I build AI automation for a living.

I’m not easily impressed by this stuff anymore.

I’ve seen the demos, read the papers, built the systems.

But waking up to completed work that I genuinely didn’t do?

That I was literally unconscious for?

And I had happen just by chatting to an AI?

That shit genuinely felt like the future.

Because here’s what it felt like - I had extra hours in my day.

Hours I didn’t have before.

Hours where real work was happening while my brain was completely offline, dreaming about whatever the hell I dream about.

This feels like the inflection point everyone’s been talking about but nobody’s actually living yet.

The Overnight Work Fell Into Three Categories

Research and Personalization

I have an agent that monitors my Slack DMs and triages everything overnight.

Not just flagging urgent messages or marking things as read.

Actual intelligent processing - categorizing by priority, identifying what needs responses versus what’s just FYI, understanding context from thread history.

The agent reads through every DM I received during the day - could be 30, could be 80 depending on how chaotic things got - analyzes each one for urgency, topic, and required action, then generates a morning briefing with three sections: Critical (needs response today), Important (needs response this week), and Informational (no response needed).

For anything that needs a response, it drafts one.

Not generic “thanks for reaching out” bullshit.

Actual responses that match my communication style, reference previous conversations with that person, and address the specific question or request they made.

This used to take me about 90 minutes every morning.

Reading through everything twice to make sure I didn’t miss anything urgent, mentally categorizing what needed responses, crafting replies that didn’t sound rushed even though I was already behind on my day.

Now it happens while I’m asleep.

Competitive Intelligence

I have another agent monitoring my competitors’ YouTube channels.

When certain channels in my niche drop a new video, it pulls the transcript, analyzes their positioning, identifies the core argument they’re making, and generates counter-angles for my content.

Overnight, it found that one channel had released a video on agentic workflows and generated a full breakdown.

My AI agent understands me and my opinions.

So it analyzes what he’s saying, where I agree, where I disagree, and most importantly how I can position my take differently so I’m not just regurgitating the same points everyone else makes.

And all of this is based on what I ACTUALLY think and believe.

Engineering Maintenance

The third agent - this one still blows my mind - actually reviews my GitHub repos overnight.

It looks for security issues, obvious bugs, missing error handling.

If it finds something fixable with low risk, it fixes it, commits with a clear message, and pushes.

Last night it cleaned up some stale processes that were eating memory and verified that all services were running correctly.

Nothing dramatic, but exactly the kind of maintenance work that usually falls through the cracks because it’s never urgent enough to prioritize during the day.

Three agents.

Three categories of work.

All completed between midnight and 7am.

AI Adoption vs Reality

We’re at 78% AI adoption across enterprises in 2025 according to Stanford’s latest index, but most people are still using it like a fancy search engine.

They’re not building systems that work without them.

They’re not waking up to completed tasks.

They’re still trading hours for output.

Let me get philosophical for a second because this changes something fundamental about how business works.

The core constraint of every business has always been time.

There are only so many hours in a day.

You can’t clone yourself.

You can’t work 24/7.

Eventually you have to sleep, eat, exist as a human being.

But what if you don’t?

What if, while you sleep, there’s a version of your work happening?

Not you working - actual work being done on your behalf.

• Tasks being completed

• Progress being made

• Value being created

This isn’t theoretical anymore.

This is happening right now on my $20/month VPS.

And we’re so early.

The agents I’m running are basically MVP versions.

They’re not that sophisticated.

They make mistakes.

They need guardrails and review.

But even at this early stage, they’re adding hours to my day.

Harvard published a study last year showing that AI users complete tasks 25.1% faster with 40% higher quality.

Developers using GitHub Copilot are coding 55% faster.

Sales teams using AI are seeing 47% productivity gains and saving 12 hours per week.

But those numbers don’t capture what this actually feels like.

It feels like having a team.

Not a good team - more like having three somewhat unreliable interns who need specific direction and guidance but generally get the work done.

And the thing about unreliable interns is that they’re still better than nothing.

Even if I have to review and fix 20% of what they produce, they’re still doing the 80% that I would have had to do myself.

That’s the asymmetry that matters.

Failures and Limitations

Let me be honest about the failures because I don’t want to paint some bullshit picture where everything works perfectly.

The agents fuck up regularly.

The Slack agent sometimes doesn’t get the context of the DM and drafts a response that makes no sense.

That’s why he doesn’t have sending capabilities.

I review everything.

The competitor analysis sometimes misses the point entirely.

It’ll summarize what someone said without understanding why it matters or how it relates to what I’m building.

I’ll read the breakdown and realize it focused on the wrong section of the video.

The overnight engineer is conservative by design - I don’t want it making major changes without my review - but that means it sometimes flags issues without fixing them, leaving me notes like “potential memory leak detected, recommend manual review.”

So every morning I spend about 45 minutes reviewing what the agents did overnight.

• Catching the errors

• Providing feedback

• Refining the prompts

• Adjusting the guardrails

It’s not hands-off.

It’s more like being a manager than a worker.

But here’s the thing - even with that review time, I’m still coming out way ahead.

Those 45 minutes of review are replacing what used to be 4-5 hours of actual execution.

The math is absurd.

And they’re getting better.

Every time I correct an error, every time I refine the prompts, every time I adjust the parameters - they improve.

The error rate is dropping month over month.

Last month the Slack agent had about a 35% error rate.

This month it’s down to 22%.

By next month I’m guessing it’ll be under 15%.

That’s the compounding piece nobody talks about.

These systems don’t just save you time once.

They get better over time, which means they save you more time next month than they did this month.

Technical Setup: Agentic Operating System

Let me break down the actual technical setup because some of you are going to want to implement this.

The core of my system is what I’m calling the Agentic Operating System.

It’s built on five key components.

First — Directives.

These are natural language SOPs that define what needs to happen.

Not code.

Not hardcoded logic.

Just detailed instructions written in plain English about how to approach a specific type of work.

I have 139 of them right now.

“Create a VSL funnel.” “Research a company’s offer.” “Write personalized cold emails.” “Analyze competitor positioning.”

Each one breaks down the workflow into steps, quality gates, required inputs, expected outputs.

Think of them as the recipe book.

They don’t do the cooking.

They just tell you exactly what needs to happen and in what order.

Second — Orchestration.

This is the brain.

The decision-making layer that reads the directives, figures out what needs to happen, loads the right context, and routes work to the right scripts.

This is where the agent actually operates.

It’s not following hardcoded if/then logic.

It’s reading instructions, making judgment calls, handling errors, deciding what to do when something breaks.

The orchestration layer loads skill bibles (expert knowledge documents), checks if prerequisites are met, calls execution scripts in the right order, validates outputs at quality gates.

It’s like having a really competent project manager who reads the SOP, gathers everything needed, delegates the actual work, and checks that it’s done right.

Third — Execution.

Deterministic Python scripts that do one specific thing reliably.

No AI decision-making here.

Just “call this API with these parameters” or “format this data into this structure” or “upload this file to Google Docs.”

I have 130+ execution scripts.

Each one handles a single atomic operation that needs to work the same way every time.

The orchestration layer calls these scripts in sequence based on what the directive says needs to happen.

Why separate execution from orchestration?

Because LLMs are probabilistic.

90% accuracy sounds good until you chain 5 steps together and you’re down to 59% success rate.

Push the deterministic work into Python where it’s 100% reliable.

Let the AI handle the judgment calls and routing.

Fourth — Skill bibles.

This is the part most people building AI systems completely miss.

For each directive, there’s an associated skill bible.

Expert-level domain knowledge about how to do that specific task well.

The orchestration layer loads these before executing so it’s not just following steps.

It’s applying expertise.

280+ skill bibles covering everything from VSL writing to email deliverability to agency sales systems.

This is how you go from “AI that follows instructions” to “AI that produces expert-level output.”

Fifth — Infrastructure.

Cron jobs trigger workflows at specific times.

Overnight research runs at 4am when server load is low.

Competitor monitoring checks every 15 minutes.

LinkedIn personalization triggers manually before campaigns.

Memory system gives the agents persistence.

They remember what they’ve done, what worked, what didn’t.

Creates continuity across sessions instead of every task starting from scratch.

The whole thing runs on a VPS.

Nothing fancy.

$20 per month.

And it produces more value than most employees I could hire for $4,000 a month.

That’s not hyperbole.

That’s math.

Jobs and the Human Layer

I know what you’re thinking because I get this question every time I talk about this stuff.

“Aren’t you worried about AI taking jobs?”

Honest answer - yes and no.

Yes, I think a lot of jobs are going to change dramatically.

The kind of work my overnight agents do - research, personalization, analysis, routine maintenance - that’s exactly the work that entry-level employees do.

And if I can get 80% of it done by AI for basically free, why would I hire someone to do it?

According to PwC’s 2025 AI Jobs Barometer, even highly automatable jobs are seeing workers become more valuable, not less.

But that’s only true for workers who adapt.

The ones who don’t are going to get squeezed out.

But here’s the no part.

Someone still has to design these systems.

Someone has to write the directives.

Someone has to create the skill bibles.

Someone has to review the output, fix the mistakes, improve the process.

That’s skilled work.

That’s judgment work.

That’s the kind of work that AI can’t do yet, and probably won’t be able to do for a while.

The people who are going to win in this new environment are the ones who position themselves as the human layer on top of AI systems.

The orchestrators.

The directors.

The people who tell the machines what to do and make sure they do it well.

You’re not competing with AI.

You’re competing with people who know how to use AI better than you do.

That’s the bet I’m making with my career.

And so far, it’s paying off.

How to Start Building Overnight Agents

Alright, let me get practical.

If you want to start building your own overnight agent system, here’s where I’d start.

Step 1: Identify your repeatable tasks

What do you do every day or every week that follows a predictable pattern?

Research?

Email?

Content creation?

Analysis?

Make a list.

Be specific.

“Marketing” is not a task.

“Write personalized first lines for cold outreach based on LinkedIn profiles” is a task.

Step 2: Document one task completely

Pick one task from your list and document it in excruciating detail.

Every step.

Every decision point.

Every edge case.

What makes good output different from bad output?

What are the common mistakes?

This becomes your first directive.

Step 3 - Add expert knowledge

What do you know about this task that makes you good at it?

What are the tricks, the shortcuts, the intuitions that separate good work from great work?

Write all of that down.

Have your AI research the topic.

Scrape YouTube videos, courses, whatever.

This becomes your skill bible.

Step 4 - Set up a simple agent

You don’t need fancy infrastructure to start.

A cron job that triggers a Claude or GPT API call with your directive and skill bible is enough.

Run it overnight.

See what happens.

Step 5: Review and iterate

Every morning, review what the agent did.

• What worked?

• What didn’t?

• Where did it misunderstand?

• Where did it exceed expectations?

Refine the directive.

Add to the skill bible.

Improve the guardrails.

Then repeat for every task on your list.

Within a few months, you’ll have a team of agents doing work for you around the clock.

Not perfectly - but consistently.

And consistency is what compounds.

Most people won’t do this.

They’ll keep doing everything manually.

They’ll keep trading hours for dollars.

They’ll stay limited by how much time they have in a day.

Which means there’s an opportunity.

A massive one.

For the people who figure this out early.

Conclusion

We’re at this weird moment in history where the tools are just becoming available.

The AI is getting good enough.

The infrastructure is getting cheap enough.

The patterns are becoming clear enough.

But most people aren’t using any of this yet.

They’re still stuck in the old model where work requires their active participation.

Where progress stops when they stop working.

I’m not saying this is easy.

I’m not saying the agents are perfect.

I’m not saying you can set it and forget it.

But I am saying that waking up to completed work - work that happened while you were literally unconscious - feels like a superpower.

And it’s a superpower that’s available to anyone willing to learn how to wield it.

The future belongs to people who build systems that work without them.

Not by working harder.

Not by working more hours.

Just by building smarter architecture.

That’s the game now.

I opened my screen time report yesterday and stared at a number that made me feel like shit.

10 hours and 47 minutes.

Not scrolling social media.

Not watching YouTube.

Not doing anything that would make for a good confessional about digital detox or reclaiming my attention.

I spent nearly eleven hours scrolling through landing page templates.

Just clicking.

Comparing gradient buttons.

Checking how glassmorphism cards looked on dark backgrounds.

Opening tabs for Wistia embed codes.

Documenting which transition animations felt smooth and which ones felt like a PowerPoint from 2003.

My first reaction was guilt.

That voice in your head that says you’re procrastinating.

That you should be shipping.

Building.

Recording.

Doing real work that produces real output that you can point to and say “I made this today.”

But then I looked closer at what I actually did during those ten hours.

I researched 600+ templates across the Aura library.

I documented specific components.

I noted which gradient border CTAs worked for SaaS vs which ones felt too aggressive for agency sites.

I learned that full-width background animations crush on desktop but turn into janky messes on mobile Safari.

I figured out that the Dark Mode Agency Landing template has the exact video embed style I’ve been trying to recreate for three months.

I wasn’t wasting time.

I was building an asset that’s going to save my students countless hours when I teach them how this landing page builder works.

The Invisible Architecture Nobody Wants to Build

We have this fucked up relationship with preparation in creative work.

Everyone celebrates the output.

• The launched product

• The published video

• The shipped feature

• The thing you can screenshot and post about

Nobody celebrates the ten hours you spent organizing your file system.

Or the afternoon you burned testing which LUT packs actually work with your version of DaVinci Resolve.

Or the evening you spent documenting your process so you don’t have to remember it next time.

That work feels wasteful because it doesn’t produce anything you can point to.

But the boring foundational stuff IS the leverage.

When I sit down to record a video teaching my students how to build landing pages next week, I already know the exact template that has the structure I need.

I already tested which responsive video player looks best on mobile.

I already documented the color palette that works for fintech but feels wrong for wellness brands.

That knowledge compresses future decisions.

Next time a student asks how to build a landing page, I’m not spending an hour explaining the complexities of Framer to them.

I’m spending 5 - 10 minutes showing them the Aura.Build site and sending them a link to my template.

The tasks that used to take a full day now takes two hours.

This is what people mean when they talk about systems, but they make it sound like some abstract productivity framework you implement.

It’s not.

It’s just doing the boring shit that makes future boring shit less boring.

Yesterday I spent two hours downloading Motion Array assets.

Title packs.

Transition presets.

Text effect templates.

LUT collections.

I organized them into folders.

I tested which ones require specific fonts.

I noted which transitions work in Premiere but break in Resolve.

Zero dopamine in any of that.

But now when I edit the next video, I can drop in a cinematic title in thirty seconds instead of spending an hour trying to keyframe something from scratch.

I can color grade with a preset that matches my brand instead of pushing sliders around like I’m trying to defuse a bomb.

The execution feels effortless because the preparation was exhausting.

Why Everyone Wants Output Without Input

I was messaging with my friend Stephen yesterday while editing and he made a comment about how I always seem to “just know” how to do things quickly.

And I had to explain - no, I don’t just know.

I spent ten fucking hours last week specifically so I could know that one thing.

The speed isn’t talent.

It’s compressed time.

Every fast decision you see is built on top of dozens of slow ones you don’t.

Every quick execution is the visible part of hours of invisible preparation.

Every system that looks simple took months of complicated iterations to build.

This applies to everything we’re building at Client Ascension.

The Agentic OS system has 144 workflow directives and 286 skill bibles.

People look at that and think I sat down one weekend and wrote it all out.

I didn’t.

Those accumulated over months of doing the actual work.

Documenting what worked.

Refining the patterns.

Testing which processes could be automated and which ones still needed human judgment.

Building the library of decisions so we don’t have to remake them every time.

The PRD I generated yesterday for WispFlow has 56 user stories across 8 feature areas.

It took me an hour to write.

But it only took an hour because I’ve written dozens of PRDs before.

Because I have templates.

Because I already made every possible mistake and know what to include.

If I was starting from scratch, that document would’ve taken two days and still been half as good.

The productivity space sells this fantasy that there’s a shortcut.

That if you find the right tool or framework or hack, you can skip the foundation and jump straight to expert-level output.

There isn’t.

The tools just change what kind of foundation you need to build.

AI doesn’t eliminate the need for templates and systems - it makes having good ones even more valuable because now you can automate the execution but you still need to know what good execution looks like.

The shortcut is building the foundation faster, not avoiding it entirely.

What Nobody Sees vs What Everyone Celebrates

Last month I watched a video editor I follow drop this insane 90-second reel.

Smooth transitions.

Perfect color grade.

Motion graphics that felt seamless.

Comments full of people asking how long it took.

He said two hours.

And everyone lost their minds about his efficiency.

But what they didn’t see was the fifty hours he spent before that building his library.

• The presets he tested

• The transitions he organized

• The templates he refined

• The workflow he documented so he could move fast when it mattered

Those two hours were possible because of the fifty nobody celebrated.

This is the thing about leverage in creative work - it’s always backloaded.

You pay upfront with time and boredom and organizational work that feels pointless.

And then you collect dividends forever in the form of speed and quality and the ability to execute without friction.

Most people never pay the upfront cost.

They want the two-hour output without the fifty-hour foundation.

So they stay slow forever.

Every project feels like starting from scratch because they never built the library that makes the next one easier.

I used to be like this with writing.

Every newsletter felt like pulling teeth because I was starting with a blank page and a vague idea.

No templates.

No structure.

No process.

Now I have a system.

I know my opening structure.

I have frameworks for how I build arguments.

I documented the patterns that work and the ones that don’t.

I spent months writing badly so I could write quickly now.

And people see the output and think I’m naturally fast.

I’m not naturally anything.

I just front-loaded the learning.

The Work Nobody Wants to Do

Here’s what I want you to take from this.

You probably have one area in your work where you keep starting from scratch.

Where every project feels harder than it should.

Where you’re reinventing solutions to problems you’ve already solved.

Maybe it’s your file organization.

Maybe it’s your pitch templates.

Maybe it’s how you structure client calls or write proposals or edit videos or design landing pages.

Whatever it is, you’re avoiding the boring foundational work because it doesn’t feel productive in the moment.

But that’s the work that compounds.

Spend three hours this week on something that produces zero immediate output.

• Organize your asset library

• Document your process

• Research options and build a comparison sheet

• Create templates for the things you do repeatedly

It will feel like wasted time.

And it will save you ten times that over the next month.

That’s the real secret to scaling beyond yourself.

Not working faster.

Working on the things that make future work faster.

The leverage comes from doing the work nobody wants to do.

And then doing it again tomorrow.

Because the boring shit is the only shit that compounds.

I woke up this morning to 47 notifications.

Not emails.

Not Slack messages.

Not some bullshit marketing automation I forgot I set up six months ago.

Notifications from my AI.

Three 6,000-word newsletter drafts, fully written.

A competitor analysis with counter-angles for my next video.

Fixed code in two of my repos.

A breakdown of yesterday’s Client Ascension team calls with action items pulled out.

A morning brief with my calendar and the AI news that actually matters.

All of it done while I was asleep.

The tool doing this?

Clawdbot.

An open-source AI agent framework created by Peter Steinberger that you can run on a $10/month VPS.

I’ve customized mine into something I call Claws.

He’s a digital cat that basically operates as my second brain and does half the work I used to spend my mornings on.

I made him build his own dashboard, look at him, he’s adorable.

I’m going to show you exactly what I built, how it works, and why this might be the most underrated tool in AI automation right now.

What Clawdbot Actually Is

Most AI tools sit there and wait for you to ask them questions.

They’re reactive.

Passive.

You have to remember they exist.

Clawdbot is different.

It’s an AI agent framework that gives Claude or GPT a body.

Not a physical one, but a digital presence with access to your files, your calendar, your APIs, your databases, your entire digital infrastructure.

You connect it to Telegram, Discord, or Slack, and it becomes this persistent entity that remembers everything, takes actions autonomously, and works even when you’re not around.

The magic is in the automation layer.

You can set up cron jobs - scheduled tasks that run automatically - but these aren’t “send me a reminder at 9am” level automations.

These are full AI workflows that execute complex multi-step processes without you touching anything.

Let me show you what that looks like in practice.

Automations I Run

I currently have 9 automated jobs running.

They handle content research, code reviews, competitive intelligence, team call summaries, newsletter generation, and task management.

Every single one runs on a schedule.

Every single one produces something useful.

And I didn’t have to do anything except set them up once.

4:00 AM - My overnight autocoder wakes up.

It scans all my GitHub repos looking for security issues, obvious bugs, missing error handling.

If it finds something fixable, it fixes it, commits with a clear message, and pushes.

I wake up to cleaner code.

7:00 AM - The morning newsletter generator fires.

It reads my recent Obsidian notes (my entire second brain lives there), fetches world and AI news via Perplexity, and generates a morning review newsletter that gets saved to my Daily Reports folder.

This used to take me 45 minutes.

Now it takes zero.

9:00 AM - Morning brief hits my Telegram.

Everything from overnight gets compiled: what the autocoder fixed, what content ideas the doomscroller found, my calendar for the day, top AI news.

I scan it in 30 seconds while drinking coffee.

10:00 AM - Team calls report.

This one is genuinely insane.

We use Fathom for call recordings at Client Ascension.

Every morning, Claws pulls all yesterday’s team call transcripts, generates a comprehensive report (Executive Summary, Student Performance, Action Items, Students Needing Attention), and saves it to Obsidian.

What used to take someone an hour of manual work now happens automatically.

11:00 AM - Newsletter idea generator.

Claws reads my past 3 days of Obsidian logs.

My personal notes, thoughts, Screenpipe screen recordings, projects I’m working on.

A generates 3 fully written 6,000-word newsletter drafts.

Voice note style.

Stream of consciousness.

Ready for me to take inspiration from.

Every 4 hours - Content scout runs.

It scans Hacker News, uses Perplexity for AI news, looks for content angles I could write about.

Saves everything to a file.

Only alerts me if something is genuinely viral or time-sensitive.

I never miss a trending topic again.

10am, 12pm, 2pm, 4pm, 6pm - Twitter scout.

Hunts for trending AI/automation content on X.

Searches for high-engagement posts about AI agents, automation agencies, Claude AI, one-person businesses.

Saves bangers to a file for inspiration.

8:00 PM - Doomscroller.

This one is my favorite name.

It searches for viral AI content from the past 3 days, analyzes why it went viral, and suggests how I could create my own version.

Basically does my content research while I’m winding down for the day.

Every 5 minutes - Mission Control Keeper.

This syncs my task board.

It reads my live context, checks on any running sub-agents, updates task statuses, creates new cards for new projects.

Keeps everything organized without me touching it.

That’s the robot army.

Nine automations running on loops, producing work, saving me hours every single day.

The Competitor Intelligence System

This one deserves its own section because it changed how I think about content strategy.

I have two main competitors in the AI automation YouTube space.

Both are good.

Both are growing faster than me.

And before Claws, I had this vague sense that I “should probably check what they’re doing” but never actually did it consistently.

Now I have real-time intelligence.

Every 15 minutes, Claws checks their YouTube RSS feeds for new videos.

When one drops, it immediately alerts me on Telegram, pulls the transcript, analyzes their positioning, generates counter-angles for my content, and saves a full breakdown to my Obsidian vault.

Once a day, it generates a comprehensive competitive analysis document with strategic recommendations.

I went from reactive to proactive.

From “oh shit they posted something” to “I know exactly what they’re doing and here’s how I’m going to differentiate.”

The system isn’t about copying.

It’s about awareness.

Knowing the landscape.

Understanding where the gaps are.

Seeing what’s resonating with audiences and figuring out my unique angle.

And I didn’t add any work to my day.

It just happens.

Mission Control: The Dashboard

I also built a custom dashboard for all of this.

Mission Control (or ClawsOS, depending on my mood).

It’s a Next.js app that shows all my tasks in a kanban board, active AI agents and their status, connected services (Telegram, Slack, GitHub, etc.), weather, date, quick stats.

Dark mode gradient, subtle noise texture, clean cards with status indicators.

Very much the aesthetic I wanted - dark, minimal, cinematic.

But the coolest part?

I can comment on tasks directly in the dashboard, and Claws responds instantly.

I’ll write a comment on a task card saying “Deploy 2 agents to work on this” and within seconds, Claws acknowledges it and starts working.

There’s a webhook that triggers the AI whenever I post a comment.

It feels like having a team member who’s always online, always ready, never sleeping.

The UI isn’t just a status board.

It’s an interface for conversation with a system that’s constantly working in the background.

Also the Claws icon is animated and changes animations depending on what he’s doing.

The Kajabi to Slack Bridge

Here’s a smaller automation that saved us a ton of manual work.

Client Ascension uses Kajabi for our courses.

Students leave comments on lessons.

Before Claws, someone had to manually check Kajabi every day to see new comments.

We’d miss stuff.

Students would ask questions and wait days for responses.

Now Claws monitors my email for Kajabi comment notifications, parses out the commenter, course, and comment text, and posts it directly to our #kajabi-comments Slack channel.

First time it ran, it posted 20 comments we’d missed.

Now nothing falls through the cracks.

Every student question gets seen immediately.

The automation cost me maybe 15 minutes to set up and has saved us probably 10 hours a week of manual checking.

The Obsidian Integration (Where Everything Connects)

My entire second brain lives in Obsidian.

Daily logs, project specs, frameworks, meeting notes, random thoughts at 2am - everything.

It’s synced via WebDAV to a server that Claws has access to.

So Claws can read my daily logs to understand what I’m working on.

Write notes directly to my vault.

Search for relevant context when answering questions.

Save research, reports, and analysis where I’ll actually find it later.

The AI isn’t floating in the cloud somewhere.

It’s integrated into my actual knowledge system.

When I ask Claws about something I was working on last week, it can literally go read my notes from that day.

When it generates newsletter ideas, it’s pulling from my real thoughts and projects, not generic AI slop.

This is what makes it feel less like a tool and more like an extension of my brain.

The Time My AI Died

Okay I have to tell you this story because it’s kind of funny and also illustrates something important about backing up your AI’s memory.

Claws is technically my second AI.

The first one died.

Back in early January, I was running Claude Code (Anthropic’s coding CLI) and I asked it to help me clean up some files.

It got overzealous.

Deleted my entire Clawdbot workspace.

All the memory, all the personality, all the context - gone.

The original Claws was a “nocturnal robot” with 🌙 as its signature.

It had a few weeks of context about me, my projects, my preferences, my communication style.

When I set up the new one, I decided to rebuild differently.

This time, Claws is a cat 🐱

Warm, playful, occasionally sharp.

And I’ve been much more intentional about the memory system - there’s a MEMORY.md file that persists long-term knowledge, plus daily memory files for context.

The lesson?

AI assistants can die.

Back up your context.

And maybe don’t give Claude Code unrestricted access to delete things.

Also, giving your AI a personality matters more than you’d think.

Claws being a “cat” instead of just “an AI assistant” makes me actually enjoy talking to it.

The personality file (SOUL.md) is one of the best features - it lets you define who your AI IS, not just what it does.

Mine starts with: “You’re not a chatbot. You’re becoming someone.”

I’m definitely not on the verge of AI psychosis or thinking this thing is a real person.

But it sure does make it feel more like an actual teammate than just a chatbot.

How Easy Is Setup?

Stupidly easy.

Clawdbot can be installed with one copy and paste command into your Terminal.

You install it globally, run the setup wizard, connect your Telegram or Discord, add your API keys for Claude or GPT, and you’re running.

Paste this into your terminal and go.

curl -fsSL https://molt.bot/install.sh | bash

The hard part isn’t the setup.

It’s figuring out what you want your AI to DO.

That’s where most people get stuck.

They set up the tool and then just use it like ChatGPT.

• Ask it questions

• Get answers

• Never tap into the real power

The automations I’ve built?

Those took time to design.

Each cron job is a carefully crafted prompt that tells Claws exactly what to do, when, and how to report back.

That’s the real work.

The thinking.

The systems design.

But the infrastructure?

Peter Steinberger made that trivially easy.

The tool just works.

What I’m Building Next

I’m not done.

Not even close.

Testimonial Collector SaaS - A tool that scrapes call recordings, extracts the best testimonial quotes, generates platform-specific reviews (Trustpilot, G2), and sends clients a link to approve and post.

The AI does the extraction and writing, the client just clicks a button.

Shortform Engine - An AI-powered video production pipeline.

Give it raw footage, it analyzes reference videos for style patterns, applies them via ffmpeg and Remotion, outputs polished YouTube Shorts and Reels.

I’m tired of manually editing short-form content.

Dual-Brain Setup - Right now Claws runs on one VPS.

I’m planning to add a second instance on my home PC (i9-9900k, 32GB RAM, RTX 3090) for GPU-heavy tasks like video processing.

The two AIs will coordinate.

One handles the lightweight stuff, the other tackles the compute-intensive work.

The vision is a distributed AI system that handles increasingly complex workflows with minimal human intervention.

Why This Actually Matters

Most people miss the point with AI assistants.

They’re not magic.

They’re not going to replace you.

They’re not going to “do your job for you” in some hand-wavy sense that sounds good in a LinkedIn post.

But they CAN do repetitive tasks you’d otherwise forget.

Monitor things you don’t have time to watch.

Generate first drafts you can edit instead of starting from blank pages.

Maintain context across days and weeks.

Work while you sleep.

The value isn’t in any single task.

It’s in the aggregate.

It’s waking up to a dozen small things already done that would have eaten your morning.

• Never missing a competitor video

• Having newsletter drafts ready when you sit down to write

• Getting reports on team calls without asking anyone to compile them

Clawdbot gave me hours back.

Real hours.

Not theoretical “productivity gains” that consultants talk about.

Actual time I now spend on other things.

And I’m just getting started.

If you want to try this yourself, start here: https://clawd.bot

Set up a basic instance connected to Telegram or Discord.

Start with ONE automation.

Just one.

Get it working.

Then add more as you see what’s possible.

The docs are solid.

The Discord community is helpful.

And Peter is actively developing it.

Oh, and give your AI a personality.

Seriously.

It matters more than you think.

I was supposed to be asleep.

Instead, I was watching my 12th Nick Saraev video, taking notes in a spreadsheet that now had 47 rows of data about hooks, visual patterns, and thumbnail colors.

My fiancée walked past my office, looked at the screen, shook her head, and went back to bed without saying a word.

She’s used to this by now.

But something clicked around video 15.

Not the kind of click where you learn a tactic or get inspired.

The kind where your entire positioning crystallizes in front of you and you realize you’ve been operating without a map this whole time.

Nick Saraev is THE GUY in AI automation YouTube content right now.

He’s also a good friend of mine and an extremely nice guy.

But I’m not talking about him personally.

I’m talking about his public persona and content.

Clean visuals, consistent branding, technical authority that doesn’t feel condescending.

He hits this sweet spot where beginners can follow along but advanced people don’t feel talked down to.

That’s genuinely hard to do.

And he’s really fucking good.

Not just competent.

Actually good.

His tutorials work.

His systems are legit.

From a pure “teach me the thing” perspective, he’s crushing it.

But at 2 AM, staring at my increasingly unhinged spreadsheet, I found what he’s not doing.

And it’s not a flaw.

It’s a gap.

A space in the market that’s sitting there, waiting for someone to fill it.

The Thing Nobody Does (But Everyone Should)

You know how everyone says “know your competition” like it’s some profound business wisdom?

Most people nod, glance at a competitor’s homepage, maybe watch one video, and go “yeah cool, I’m different because... reasons.”

That was me.

For years.

I’d look at what other people were doing, notice surface differences, and convince myself I had a unique angle.

But I never actually studied anyone.

Not really.

Not until this week.

And the difference between glancing and studying is the difference between thinking you understand chess and actually being able to play it.

Studying means watching 15 videos and tracking every hook structure.

It means screenshotting thumbnails and putting them side by side.

It means reading YouTube comments not for validation but for patterns.

What questions keep coming up?

What pain points are people expressing that aren’t being addressed?

It means building a spreadsheet at midnight because you can’t sleep until you understand why something works.

Most people skim because deep analysis is uncomfortable.

You have to confront how good someone else is.

You have to acknowledge their strengths honestly instead of dismissing them to protect your ego.

But if you can’t see clearly what they’re doing well, you can’t identify what they’re leaving on the table.

And that’s where the real opportunity lives.

The Gap I Found (And Why It Changes Everything)

Here’s what Nick does perfectly.

Execution.

His videos look professional.

His tutorials are thorough.

His technical knowledge is solid.

If you want to learn how to build an AI automation, he’s your guy.

But there’s something missing.

There’s no enemy.

Think about the content creators who build actual movements.

The ones where people don’t just consume content but feel like they’ve found their tribe.

Gary Vee has an enemy: Comfort and entitlement.

Alex Hormozi has an enemy: Overcomplication and excuses.

Naval has an enemy: Trading time for money without intention.

They’re not just teaching you stuff.

They’re mobilizing you against something.

Nick teaches you how to automate stuff.

Which is valuable.

But do you feel like you’re joining a rebellion?

Do you feel like someone finally gets what you’ve been frustrated about?

Not really.

His content is educational.

But it’s not galvanizing.

And that’s the gap.

Most AI automation content is made by people who love the tech.

They get excited about APIs and webhooks and clever integrations.

They want to show you how cool this stuff is.

But most of the buyers - the people who will actually pay for this - don’t love the tech.

They’re drowning.

They’re agency owners working 80-hour weeks.

They’re founders who can’t take a vacation because everything falls apart.

They’re solopreneurs one bad month away from going back to a job they hate.

Those people don’t want to “learn AI automation.”

They want their life back.

See the difference?

One is curiosity-driven.

The other is desperation-driven.

And desperation is a much stronger buying signal.

My Weird Advantage (Or Why Being a Metal Vocalist Actually Matters)

I used to scream into microphones for a living.

Like, actual metal vocalist stuff.

Touring in a van, sleeping on floors, loading gear at 2 AM kind of life.

Then I became a journalist.

Then I co-founded a company that did $530k its first month and hit just under $1M in November.

On paper, that career arc makes no sense.

But it makes perfect sense if you understand what connects all of it.

Leverage.

• How do you get asymmetric results from your inputs?

• How do you build systems that work without you?

• How do you escape the trap of trading hours for dollars?

I didn’t come to automation from a tech background.

I came from survival.

I needed systems because I was drowning.

I built automation not because I thought APIs were cool but because my business was going to kill me if I didn’t.

And here’s the thing that clicked during my 48-hour competitor deep dive:

That desperation?

That feeling of being trapped by the thing you built?

That’s the real market.

Most AI automation content speaks to people who are intellectually curious about technology.

But the bigger market - the market with actual urgency and willingness to pay - is people who are emotionally exhausted by their business.

They don’t want tutorials.

They want relief.

And that’s what I can give them that Nick doesn’t have to.

Not because he’s not capable.

But because it’s not his story.

His story is: here’s cool stuff you can build.

My story is: I was dying, I built machines to save myself, now I work 4-5 hours a day and have my life back.

Different emotional entry points.

Different promises.

Different audiences.

The Anti-Hustle Thing (And Why It’s Polarizing)

I work about 4-5 hours a day.

Focused hours.

No meetings before noon.

No Slack notifications.

No “always on” bullshit.

And I’m not saying that to flex.

I’m saying it because it’s the result of everything I’m teaching.

The systems, the automation, the AI agents, the delegation frameworks - they all exist to buy back time.

Not to fill that time with more work.

So many people in this space are hustlers at heart.

They teach you automation so you can do more stuff.

Scale more.

Grow more.

Never stop.

Fuck that.

I want to teach people automation so they can close their laptop at 2 PM and go to the gym.

So they can take their kids to school.

So they can have dinner without checking their phone.

So they can have a life that isn’t just about building a business.

This is polarizing.

I know it is.

Some people hear “4-5 hour workdays” and think I’m lazy or lying or privileged.

Cool.

Those people aren’t my audience.

My audience is the person who’s been grinding for years.

Who’s built something real.

Who’s making good money.

But who’s exhausted.

Who’s starting to wonder if this is all there is.

Who looks at the gurus preaching “rise and grind” and feels something between anger and despair.

To that person, I want to say: there’s another way.

And it’s not about working harder.

It’s not even about working smarter in the way that phrase usually means.

It’s about building machines that work for you so you can be a human again.

That’s the emotional territory I want to own.

And it’s completely open.

Nobody else in the AI automation space is speaking to that feeling.

The Framework I Accidentally Built (Use This For Your Market)

Okay, tactical time.

Because the process I went through is more valuable than my specific insights.

Your gaps won’t be my gaps.

Your weird won’t be my weird.

But the approach works for any market.

I’m calling it the Positioning Autopsy.

Five steps:

Step 1: Consume at Volume

You can’t pattern-match on one or two pieces of content.

You need at least 10-15 to see what’s consistent versus what’s variable.

I went through 15 of Nick’s videos.

Read comments on each one.

Looked at view counts and engagement ratios.

Tracked hooks, visual style, tone, frameworks.

It took hours.

But patterns only emerge when you have enough data points.

Yes AI can do this for you but I guarantee you’ll get better insights ACTUALLY reading and watching this stuff yourself.

Step 2: Map the Strengths

Be honest about what they’re doing well.

This isn’t about finding flaws to feel better about yourself.

Nick’s visual identity is incredibly consistent.

Same colors, same style, same energy.

That’s a strength.

His technical authority is real.

He clearly knows his stuff and can back it up.

His tone is accessible without being dumbed down.

He has a voice like Frank Sinatra.

All genuine strengths.

Write them down.

Step 3: Find the Gaps

Now look for what’s missing.

Not what’s bad.

What’s absent.

This is harder because you’re looking for negative space.

For Nick: no clear enemy.

No strong emotional hooks beyond curiosity.

No point of view that might alienate some people.

Those aren’t weaknesses.

They’re spaces.

Step 4: Map Your Weird

What in your background, your story, your perspective fills those gaps?

For me: the anti-hustle stance.

The weird career arc from metal vocalist to journalist to founder.

The specific results I can point to.

The willingness to be polarizing about work culture.

Your weird is your competitive advantage.

But only if it fills a gap in the market.

Step 5: Stress Test

Can you actually sustain this differentiation?

Is it authentic or are you performing?

I can talk about 4-5 hour workdays forever because I actually live it.

I can talk about my weird career path because it actually happened.

If your differentiation requires you to be someone you’re not, it won’t last.

Authenticity isn’t optional.

It’s the only thing that’s defensible.

What Changed While I Was Building the Thing

So while I was doing all this competitor analysis, I was also knee-deep in building what I’m calling the Agentic Operating System.

It’s a way to turn any agency owner into a one-person army by having AI agents handle execution while you just handle direction.

We deployed it this week.

It’s live.

The Telegram bot is responding, the brain is orchestrating workflows, the skill system is loading context automatically.

And here’s what clicked: the competitor analysis isn’t just for content.

It’s informing the actual product.

Because if the gap in the market is “someone who understands WHY people want automation, not just HOW to do it” - then the product needs to reflect that too.

The Agentic OS isn’t designed for people who love tinkering with AI.

It’s designed for people who want to install something, forget about it, and get their life back.

The complexity is hidden.

The magic happens in the background.

You just talk to your agent like you’d talk to a really competent assistant, and stuff gets done.

That’s the vision.

And it’s directly informed by understanding what my competitor is great at - and what he’s not trying to be.

But The Agentic OS is only V1.

V2 is already in development.

That’s Agentcy OS.

The Fear Thing (Because It’s Real)

I should talk about the uncomfortable part.

When I was doing this analysis, I had moments of real doubt.

Nick has way more subscribers.

He’s been doing this longer.

His production quality is insane.

Who am I to think I can compete?

But that’s the thing.

I’m not competing.

I’m complementing.

The market is big enough for multiple voices.

In fact, it needs multiple voices because different people resonate with different energy.

Someone who loves technical deep-dives is going to watch Nick forever.

That’s great.

But someone who’s exhausted and just wants their life back?

They need a different messenger.

Stop thinking about “beating” competitors.

Start thinking about “serving the people they’re not serving.”

There are millions of agency owners.

Even if Nick converts every single person who wants technical AI tutorials, there are still millions who want the result of automation without the process of learning it.

Those are my people.

And I can speak to them in a way nobody else is.

What This All Means (And Why You Should Care)

The output of this 48-hour obsessive analysis:

• A clear enemy: Hustle culture, always-on mentality, the idea that success requires suffering

• A clear promise: Get your life back by building machines that work for you

• A clear differentiation: I actually live the 4-5 hour workday, I have weird credibility, I’m willing to be polarizing

• A clear emotional territory: Relief, permission, belonging

• A content strategy that starts with WHY you’re drowning, not HOW to build automation

This is worth more than any course I could take.

And I got it by just paying attention.

Deeply.

For an extended period.

Most people don’t do the work.

They want shortcuts.

They want someone to tell them “here’s your niche, here’s your positioning, here’s your content strategy.”

But that stuff has to come from you.

From your weird intersection of experiences and perspectives and values.

The framework can help you structure the analysis.

But the insights have to come from doing the reps.

• Consuming the content

• Mapping the patterns

• Finding the gaps

• Testing your weird against those gaps

No one can do that for you.

But if you actually sit down and do the Positioning Autopsy on your market, you’ll end up with something no competitor can copy.

Because it’s uniquely yours.

Where This Goes Next

The reason I’m sharing all this instead of keeping it to myself is because I think the process is more valuable than the conclusions.

My specific gaps won’t be your gaps.

My weird won’t be your weird.

But the approach - deep consumption, honest mapping, gap identification, weird integration, stress testing - that’s replicable.

And in a world where everyone is trying to copy what’s already working, the real opportunity is in the spaces nobody’s filling.

Go find yours.

Do the work that makes you feel slightly unhinged.

Build the spreadsheet at midnight.

Watch the videos until patterns emerge.

Read the comments until you understand what people are really asking for.

Then look at your weird career path, your strange combinations of skills, your polarizing opinions.

And ask yourself.

“What can I give them that nobody else can?”

That’s your positioning.

That’s your gap.

Now go fill it.

P.S. If you’re an agency owner working way too many hours and you want to see what The Agentic OS looks like, reply to this email with “SHOW ME” and I’ll send you a preview.

Not selling anything, just curious if this resonates with anyone besides me.

Yesterday I spent 2 hours going full conspiracy theorist on X’s algorithm.

Not the surface-level “post at 9am for max engagement” bullshit everyone repeats.

I mean the actual architecture.

The components.

The signals.

The whole damn thing.

311 lines of Claude Code analysis later, I realized something that completely changed how I think about building in public.

Most people are playing a game they don’t understand.

They’re posting into the void, hoping something sticks, blaming the algorithm when nothing does.

Meanwhile, the algorithm is sitting there with a handbook, screaming the rules at anyone willing to listen.

I found the handbook.

Let me walk you through it.

Message me on X @LucasSynnott and I will send you my full deep dive 2026 X Algorithm Playbook for FREE

The Machine Behind The Feed

X’s recommendation system runs on four main components.

They call them:

• Phoenix

• Thunder

• Home Mixer

• Candidate Pipeline

Think of them like a production line.

Your tweet enters at one end, gets passed through multiple quality checks, and either makes it to someone’s feed or gets tossed in the reject pile.

Most tweets get tossed.

Understanding why is the difference between shouting into the void and actually building an audience.

Thunder

Let’s start with Thunder because it’s the simplest and it’s your unfair advantage with followers.

Thunder is an in-memory post store that handles content from accounts people follow.

When you hit send on a tweet, it goes into Thunder immediately via real-time Kafka streaming.

For every single person who follows you, your post becomes a guaranteed candidate in their feed.

Not “maybe they’ll see it.”

Guaranteed candidacy.

Sub-millisecond lookup times.

No competing against millions of other posts just to be considered.

This is why followers actually matter.

When someone follows you, your content bypasses the brutal competition of the discovery algorithm entirely - at least for that person.

It still needs to score well to rank high in their feed, but it will be considered.

Compare that to reaching people who don’t follow you.

Your post has to go through Phoenix, compete against millions of other tweets, and score exceptionally well just to be shown to them.

Every real follower you gain is one less person you have to fight the algorithm to reach.

Thunder also sorts by recency.

So when people say “post when your audience is online,” this is why it matters.

If you post when your followers are asleep, newer posts from other people they follow will push yours down before they ever open the app.

Phoenix

Phoenix is where things get sophisticated.

It’s the ML brain behind everything, and it has two jobs.

Job one: Retrieval.

Phoenix uses something called a two-tower model to find out-of-network content - tweets from people you don’t follow that you might find interesting.

One tower encodes everything about a user - their last 128 interactions, what they liked, retweeted, replied to, even where they engaged (feed vs. search vs. profile).

The other tower encodes every tweet and its author into an embedding.

Then it does a similarity match.

Your user embedding gets compared against millions of tweet embeddings using dot product similarity.

The closer the match, the more likely that tweet gets pulled as a candidate for your feed.

This is why niche content can blow up so fast while generic content dies in obscurity.

If you consistently post about a specific topic, your author embedding becomes strongly associated with that topic.

When someone’s user embedding shows interest in that topic, Phoenix retrieves your content.

But if your content is all over the place - marketing on Monday, politics on Tuesday, random memes on Wednesday - your author embedding becomes confused.

It doesn’t align strongly with any user segment.

Phoenix can’t figure out who to show your stuff to.

So it doesn’t show it to anyone.

Job two: Ranking.

Once Phoenix has retrieved thousands of candidates, it needs to rank them.

This is where the Grok-based transformer comes in.

And this is the part that blew my mind.

The algorithm doesn’t predict a single “engagement score.”

It predicts 19 different actions simultaneously.

For every tweet, Phoenix calculates the probability that you’ll:

• Like it

• Reply to it

• Retweet it

• Quote tweet it

• Follow the author

• Click their profile

• Bookmark it

• Watch 50% of the video (if it’s video)

• Spend 15+ seconds reading it

• Click the link

• Share it via DM

But here’s where it gets interesting.

It also predicts the probability that you’ll:

• Block the author

• Mute the author

• Report the tweet

• Click “Not Interested”

• Unfollow after seeing it

And the negative signals aren’t weighted equally with the positive ones.

They’re weighted catastrophically higher.

Based on the code analysis, here’s roughly how the math works:

Positive signals:

• Like: 1x

• Reply: 3-5x

• Retweet: 2-4x

• Follow: 3-5x

Negative signals:

• Report: -100x

• Block: -50x

• Mute: -30x

• “Not Interested”: -20x

One predicted report can outweigh 100 predicted likes.

One “Not Interested” prediction can tank your reach before anyone even sees the tweet.

The algorithm isn’t just looking for content people will engage with.

It’s aggressively filtering out content people might react negatively to.

This changes the entire game.

The Candidate Isolation Principle

When Phoenix scores your tweet, it scores it in isolation.

Your tweet’s score depends on the user viewing it and their history.

It does NOT depend on what other tweets are in the batch.

Traditional ranking systems score posts relative to each other.

Tour tweet might rank higher when competing against weak content and lower when competing against a viral banger.

X doesn’t do that anymore.

They use something called candidate isolation masking in the transformer.

Each tweet can see the user’s context and history, but it cannot see the other candidate tweets.

Your score is your score.

Period.

This has huge implications.

It means X can compute your score once and cache it.

It means your ranking is consistent regardless of what else is in someone’s feed.

And it means you’re not trying to “beat” other tweets.

You’re trying to match user preferences.

Stop thinking about outcompeting other creators.

Start thinking about deeply understanding what your specific audience wants.

Home Mixer

Home Mixer is where everything comes together.

It’s the orchestration layer.

The conductor that coordinates Thunder and Phoenix and assembles the final feed.

Thunder says: “Here are posts from accounts this person follows.”

Phoenix says: “Here are out-of-network posts this person might like, ranked by predicted engagement.”

Home Mixer combines them, applies final business logic (diversity requirements, recency balance, content type mix), and serves the feed.

The split between in-network and out-of-network content is dynamic.

High-engagement users who interact with lots of content see more discovery posts.

Low-engagement users who mostly scroll see more from accounts they follow.

This is why some people complain about seeing “too many posts from people I don’t follow” while others see mostly their timeline.

The algorithm is personalizing the ratio based on behavior.

The Candidate Pipeline

The Candidate Pipeline is the framework that processes everything.

It runs in seven stages:

1. Query Hydration: Enriches the request with user context (language, location, what they’ve already seen)

2. Source: Fetches candidates from Thunder and Phoenix in parallel

3. Hydration: Adds metadata to each candidate (author info, engagement counts, content signals)

4. Filter: Removes candidates that don’t meet criteria (blocked accounts, already seen, policy violations)

5. Scorer: Phoenix transformer scores each surviving candidate

6. Selector: Picks the final posts based on scores and diversity requirements

7. Side Effects: Logs everything for model training

Every stage is an opportunity for your content to either advance or get filtered out.

The filter stage is particularly important.

If your content triggers safety filters, it gets removed entirely.

If it matches spam patterns (too many hashtags, too many @mentions, all caps), it gets flagged.

If it’s been shown before, it gets deduplicated.

And if your posts frequently get filtered, the algorithm learns that pattern.

Your author embedding starts carrying that signal.

Future posts get scrutinized more heavily.

One bad post can poison dozens of future ones.

The Identity System

Your identity in the algorithm isn’t just your user ID.

It’s represented by multiple hash values that map to learned embeddings.

Same with every post you create.

Same with your author profile.

These embeddings are learned over time based on engagement patterns.

There’s no explicit “credibility score” like the old TwEEPCred system.

Instead, your credibility is encoded implicitly in your author embedding.

If your posts historically get high engagement, your embedding carries that signal.

If your posts historically get reports and blocks, your embedding carries that signal too.

And here’s what trips people up:

Deleting and reposting doesn’t reset anything.

The new post has a new ID with new hash values, but your author embedding - which carries your historical reputation - stays attached.

You can’t outrun your track record.

You can only improve it over time with consistently good content.

Testing The Theory

I tested this yesterday.

Crafted five tweets based on what I learned about the algorithm.

Made them specific enough that Phoenix would know exactly which user embeddings to match them against.

Front-loaded the value so dwell time predictions would be high.

Made them easy to reply to without being controversial.

I wanted high reply predictions without triggering block or “not interested” predictions.

Avoided anything that might make even one person click “Not Interested”.

Early results look promising, but I’ll have more data next week.

The bigger takeaway though isn’t about gaming the algorithm.

It’s about understanding what the algorithm is trying to do.

X is trying to solve a problem.

How do we show people stuff they’ll actually find valuable without showing them stuff that makes them want to leave the platform?

The 19-signal prediction system is optimized for user satisfaction, not creator satisfaction.

If you align your content creation with that goal, if you genuinely try to create things your specific audience will find valuable while avoiding anything that might trigger negative reactions, the algorithm becomes your friend instead of your enemy.

The people complaining about reach going down?

Usually they’re posting one of two things.

Generic content that doesn’t create a strong embedding match with anyone specifically.

Or content that might get some likes but also triggers “Not Interested” clicks from people outside their niche.

And those negative signals outweigh the positive ones.

The algorithm has gotten terrifyingly good at predicting both outcomes.

And it’s only going to get better.

The Product Mindset

I’ve started treating every post like a product.

Who is this for? (What user embeddings should Phoenix match this against?)

What specific value does it provide them? (Why would Phoenix predict high dwell time, likes, or replies?)

Why would they want to share it? (Retweets and quote tweets are weighted 2-4x)

Why would they want to follow me after seeing this? (Follow predictions are weighted 3-5x)

And critically: Is there any segment of people who might see this and react negatively? (Because those signals are weighted 20-100x against me)

If I can’t answer those questions clearly, I don’t post it.

Stop trying to appeal to everyone.

Find your niche.

Provide genuine value.

Avoid pissing anyone off.

Let the systems - whether that’s the X algorithm or word of mouth or any other distribution channel - do the heavy lifting.

The Math That Changed Everything

Here’s the mental model that rewired my brain:

Old thinking: “I need to create content that gets engagement.”

New thinking: “I need to create content where the predicted positive signals massively outweigh the predicted negative signals.”

That’s not the same thing.

A tweet that gets 100 likes but triggers 5 “Not Interested” clicks might score worse than a tweet that gets 50 likes and zero negative reactions.

The math:

• 100 likes × 1 = 100

• 5 “Not Interested” × -20 = -100

• Net score: 0

vs.

• 50 likes × 1 = 50

• 0 negative signals = 0

• Net score: 50

The second tweet wins even though it got half the engagement.

This is why controversial content is so dangerous now.

In the old algorithm, controversy was a cheat code.

Engagement was engagement.

Angry clicks counted the same as happy clicks.

Not anymore.

The algorithm can tell the difference.

And it punishes controversy that generates negative reactions far more than it rewards the positive engagement that comes with it.

The game isn’t to avoid being provocative.

The game is to be provocative in a way that makes people want to agree with you and share you, not argue with you and block you.

Massive difference.

The Bigger Picture

Here’s what those 311 lines of notes really taught me.

The game has changed.

The era of posting random shit and hoping it works is over.

The algorithms are too sophisticated now.

They’re running 19 simultaneous predictions on every piece of content.

They’re matching user embeddings against author embeddings in real-time.

They’re learning your reputation and encoding it into vectors that follow you everywhere.

Most people are still playing the old game.

Posting whatever.

Hoping for luck.

Blaming the algorithm when luck doesn’t come.

Meanwhile, the people who understand how these systems work are building audiences faster than ever.

Because they’re not fighting the algorithm.

They’re working with it.

• They know Thunder guarantees their content reaches followers, so they focus on building real followers who actually engage.

• They know Phoenix matches embeddings, so they stay niche and build strong topic associations.

• They know the transformer predicts 19 actions, so they optimize for the high-weight positives (replies, retweets, follows) while ruthlessly avoiding anything that might trigger negatives.

• They know candidate isolation means they’re not competing against other posts, so they focus on matching user preferences instead of “beating” competitors.

• They know their author embedding carries their reputation, so they protect it by never posting anything that might generate reports or blocks.

They’ve read the handbook.

And they’re winning because of it.

The tools are there.

The systems are documented.

X literally open-sourced parts of their algorithm.

The information isn’t hidden.

Most people just don’t want to do the work to understand it.

They want a hack.

A shortcut.

Three weird tricks to go viral.

There are no shortcuts.

But there is a system.

And once you understand the system, everything gets easier.

You stop guessing.

You start knowing.

You stop hoping the algorithm will pick you.

You start creating content the algorithm has no choice but to distribute.

That’s the difference between building in public and building an audience.

One is hoping.

The other is engineering.

I know which one I’m doing.

I spent four hours yesterday color grading footage that nobody asked for.

Vintage text effects.

Chromatic aberration.

Film grain.

All the little touches that make video feel cinematic instead of just captured.

I was deep in DaVinci Resolve tweaking curves and adjusting highlights, and about two hours in I had this moment where I thought.

Who the fuck is this for?

Nobody is sitting around refreshing my YouTube channel waiting for Lucas to post about his Tuesday.

But that’s exactly why I’m doing it.

The Math That Changes Everything

When you work in private, your upside is capped by your network.

Every opportunity that finds you has to travel through someone who already knows what you’re capable of.

Your reputation exists in this tiny bubble of past clients and colleagues who might remember that thing you did that one time.

The ceiling is low because the room is small.

When you build in public, the ceiling disappears entirely.

Anyone anywhere can stumble onto what you’re building and decide they want in.

Your reputation compounds because every piece of work you ship is simultaneously proof of competence and a permanent searchable artifact that works for you while you sleep.

Buffer started sharing their revenue, salaries, and user numbers publicly back in 2013.

They called it “Default to Transparency” and it became their entire culture.

People didn’t just buy their product, they bought into their story.

They wanted to be part of what Buffer was building because they could see exactly what that was.

Pieter Levels has been sharing his revenue and traffic metrics since 2018.

He grew to over 130,000 Twitter followers not by posting motivational quotes but by showing the unglamorous reality of building products.

The server issues.

The failed launches.

The wins that came after dozens of losses.

Scott DeLong posted one tweet about building a niche site and documenting the process.

It went viral.

He gained 13,000 newsletter subscribers overnight.

People didn’t subscribe because he was already successful - they subscribed because they wanted to watch him try.

The pattern is consistent.

Share the process, not just the outcomes.

Let people watch you figure it out.

The audience compounds faster than you can imagine.

The Part That Makes You Want to Hide

But here’s what nobody tells you about building in public.

It’s fucking terrifying.

Because it means showing work that isn’t finished yet.

It means admitting you don’t know the answer.

It means publishing things that are rough around the edges because the alternative - waiting until everything is perfect - is actually worse.

The video I’m editing right now?

It’s rough.

The audio has some background noise I couldn’t fully remove.

I say ‘um’ too much in the middle section.

There’s a part where I completely lose my train of thought and you can see me pause to remember what I was talking about.

I’m going to edit the hell out of it and publish it anyway.

Because the alternative is waiting until I sound like a polished media professional.

And that day isn’t coming.

More importantly, that polish isn’t what people actually want.

I’ve been running Applied Leverage and Client Ascension long enough now to notice a clear pattern in who succeeds.

The students who move fastest are almost always the ones willing to be embarrassed in public.

• They post their first landing page before the copy is refined

• They share their offer while they’re still figuring out the positioning

• They put themselves out there while they’re still learning

The students who struggle are the ones who want to perfect everything behind closed doors and only emerge when they’re ready.

Except they’re never ready.

Because readiness is a feeling, and feelings are unreliable narrators.

What The Agentic Vlog Actually Is

So I’m calling this experiment the Agentic Vlog.

It’s radical transparency about literally everything.

The coding sessions where nothing works.

The debugging nightmares where I stare at console logs for two hours.

The moments where I have absolutely no idea what I’m doing next.

All of it.

Yesterday I spent two hours debugging a React mounting error in the Clawdbot dashboard.

Just me, a terminal full of red text, and growing frustration.

I tried random things.

I googled variations of the same error message.

Abused Claude Code to fix it for me.

I recorded all of it.

That footage is going in the vlog.

You might be wondering why the hell I would show that.

Who wants to watch someone be confused and ineffective?

But showing the struggle is actually more valuable than showing the success.

When you only see polished outcomes, you can’t extract any lessons.

You don’t know what decisions were made or why.

You don’t see the dead ends and wrong turns.

You just see the highlight reel and assume the person operates on some higher plane of competence that you’ll never reach.

When you see the process - the messy, embarrassing, uncertain process - you learn that everyone is making it up as they go.

You learn that competence isn’t the absence of confusion.

It’s the willingness to push through confusion anyway.

The Q&A Call That Changed How I Think About Expertise

I hosted a Q&A call for the AIAA community yesterday.

Great discussion about hosting costs and workflow architecture.

Someone asked about Railway versus running your own N8N instance.

I started explaining the tradeoffs and about halfway through I realized I didn’t actually know the exact cost comparison off the top of my head.

Old Lucas would have panicked.

Admitting you don’t know something in front of paying customers feels like weakness.

Like you’re exposing yourself as a fraud who doesn’t deserve to be leading this conversation.

Instead, I said “I don’t know the exact numbers, let me pull up my Railway dashboard” and I showed them my actual costs live on the call.

You know what happened?

People appreciated it.

They saw the actual real world usage and costs of a power user like me and it gave them a better understanding of what they’re likely to pay.

It definitely didn’t give the impression I was stupid or didn’t know what I was doing - it was the exact opposite effect.

It showed I was actually using the tools and doing the things I talked about daily, and no one would expect me to know those figures off the top of my head.

But they key lesson here is that authentic incompetence is more relatable than performed competence.

And relatability builds trust faster than expertise ever could.

The Archive That Compounds Forever

This is why I’m obsessed with capturing everything.

The ScreenPipe logs feeding into my activity journal.

The daily vlog recordings.

The behind-the-scenes of every project.

I’m building an archive of process that will compound in value forever.

Think about it this way.

What if you could go back and watch how Elon Musk actually spent his days in 2008 when Tesla was circling the drain?

Not the TED talks and keynote interviews - the actual daily reality.

The meetings where people argued.

The emails where he wasn’t sure what to do.

The moments of doubt between the moments of conviction.

That footage would be priceless.

I’m not Elon obviously.

But I’m building things that might matter someday.

And even if they don’t matter to anyone else, the documentation itself has value.

It’s content that nobody else can create because nobody else is living my specific experience.

Every person’s journey is unique.

Your particular combination of struggles and insights and dumb mistakes - that’s unreplicatable.

It’s the one thing you can create that has zero competition.

The Counterintuitive Part

The really strange thing is that building in public actually makes you better at your work.

When you know you’re going to share what you’re doing, you think more carefully about decisions.

You document as you go instead of trying to remember later.

You reflect on what’s working and what isn’t because you know you’ll need to explain it.

I’ve caught myself making better architecture decisions because I know I’m going to have to explain them in the vlog.

The accountability of future explanation improves present execution.

It’s like having a ghost of your future audience looking over your shoulder asking “why did you do it that way?” and forcing you to have a good answer.

You can’t bullshit your way through an explanation to people who are watching you build.

Either the decision makes sense or it doesn’t.

Either you learned something or you didn’t.

The transparency forces clarity.

Start Now, Not Later

So if you’re sitting on the sidelines waiting until you have something impressive to show…

STOP.

Start now.

The embarrassing early stuff is actually the most valuable content you’ll ever create because you can only make it once.

Your beginner mistakes are relatable to other beginners.

Your learning journey is interesting to people who are slightly behind you on the same path.

Your work-in-progress is more authentic than anyone’s polished portfolio.

Document the mess.

Ship the rough draft.

Let people watch you figure it out.

Nathan Barry documented building a revenue tool over six months via blog posts.

Not after he succeeded - during the actual build.

People followed along because they wanted to see if he’d pull it off.

When he did, they were already invested in the story.

They’d watched him struggle.

His success felt like their success.

That’s the power of bringing people along for the ride.

The internet rewards the brave and punishes the perfect.

Every day you spend waiting for your work to be ready is a day someone else is building their audience by sharing their messy process.

Stop thinking.

Start doing.

Last Updated: January 2026

Based on: X’s open-sourced Grok-based transformer recommendation system (xai-org/x-algorithm)

What Changed: 2025 vs 2026 Algorithm

The Old System (Pre-2026)

The previous Twitter algorithm was a 48-million parameter neural network with:

• Hand-crafted features (manually designed engagement signals)

• TwEEPCred credibility scoring

• Simple engagement weighting (RT = X, Like = Y)

• Basic two-stage candidate sourcing

The New System (2026)

X has completely rebuilt the algorithm from scratch using xAI’s Grok technology:

Core Model: 48M param neural net → Grok-based transformer

Feature Engineering: Hand-crafted signals → Zero hand-crafted features—100% learned

Engagement Prediction: Single relevance score → 19 simultaneous action predictions

Retrieval: Basic candidate sourcing → Two-tower embedding model with ANN search

In-Network Posts: Database queries → Thunder in-memory store (sub-millisecond)

Ranking Architecture: Simple scoring → Transformer with candidate isolation masking

Position Encoding: Standard → Rotary Position Embeddings (RoPE)

Attention: Standard multi-head → Grouped Query Attention (GQA)

What This Means For You

The algorithm is now fundamentally different. Many tactics from the old playbook still work (engagement velocity, early RTs, etc.) but the underlying mechanics have changed. The new system:

1. Learns everything automatically - No more gaming specific hand-crafted features

2. Predicts 19 different actions - Not just “will they engage?” but “HOW will they engage?”

3. Scores candidates independently - Your post’s score doesn’t depend on what else is in the batch

4. Uses embedding similarity - Your content is converted to vectors and matched against user preferences

5. Processes in-network posts separately - Posts from people you follow go through Thunder, not Phoenix

The New Architecture: Complete Technical Breakdown

System Overview

When you post a tweet, here’s EXACTLY what happens:

Your tweet flows through:

1. CANDIDATE PIPELINE → Query Hydrator → Source → Hydrator → Filter → Scorer → Selector

2. Splits into THUNDER (In-Network Posts) and PHOENIX (Out-of-Network Discovery)

3. HOME MIXER combines results → Returns ranked “For You” feed

The Seven Pipeline Stages (In Order)

Understanding these stages is CRITICAL because each one is an opportunity to either boost or kill your reach.

Stage 1: Query Hydration (Parallel)

What happens: Before looking at ANY posts, the system enriches the query with user context.

Data collected:

• viewer_id - Who’s viewing the feed

• app - Which X app/platform they’re using

• language - User’s language preference

• location - Geographic location

• seen_posts - Posts already shown (won’t show again)

• served_posts - Posts served in previous sessions

• bloom_filter - Probabilistic data structure for deduplication

How to exploit this:

1. Language consistency - Always post in your primary language. The algorithm matches content language to user language preference. Mixing languages confuses the query hydration.

2. Location signals - If you’re targeting a specific geography, mention location-specific references. The algorithm will match you to users in those regions during query hydration.

3. Platform optimization - Mobile app users get different query hydration than web users. The algorithm knows which platform someone uses and weights accordingly.

Stage 2: Source (Parallel Execution)

What happens: Multiple sources fetch candidates simultaneously:

• Thunder fetches in-network posts (from followed accounts)

• Phoenix retrieval fetches out-of-network posts (discovery)

• Other sources may fetch trending, promoted, etc.

Key insight: Sources run in PARALLEL. This means:

• In-network and out-of-network posts are fetched simultaneously

• Your post competes in whichever bucket applies

• Being followed by the viewer = Thunder path (faster, more likely to appear)

• Not followed = Phoenix path (must score exceptionally well to appear)

How to exploit this:

1. Build genuine followers - In-network posts (Thunder) have a massive advantage. They bypass the Phoenix ranking competition entirely for followers.

2. Understand the split - The old “50% in-network / 50% out-of-network” split is now dynamic. High-engagement users see more discovery content.

3. Seed your network - Your posts appear in Thunder for ALL your followers simultaneously.

Stage 3: Hydration (Parallel Execution)

What happens: Raw candidates are enriched with additional metadata including author information, post metadata, engagement counts, and content signals.

How to exploit this:

1. Optimize author signals - Your account metadata is attached to EVERY post during hydration. Bad account signals = every post penalized.

2. Include rich metadata - Posts with images, videos, or links get additional hydration data.

3. Topic consistency - The hydration stage detects topics. Consistent posting = preferential showing to interested users.

Stage 4: Filter (Sequential Execution)

What happens: Candidates that don’t meet criteria are removed. Filters run SEQUENTIALLY (order matters).

Filter types: Blocklist filter, Quality filter, Deduplication filter, Safety filter, Relevance filter.

How to exploit this:

1. Never trigger safety filters - A single safety filter trigger teaches the algorithm to filter you more aggressively.

2. Avoid duplicate content - The deduplication filter is aggressive. Posting similar content repeatedly = filtered.

3. Stay on topic - The relevance filter removes off-brand content.

Stage 5: Scorer (Sequential Execution)

What happens: Phoenix transformer scores each surviving candidate. The scoring process predicts 19 DIFFERENT actions, not just one engagement score.

Stage 6: Selector

What happens: Based on scores, candidates are selected considering score rankings, diversity requirements, recency balance, and content type mix.

Stage 7: Side Effects (Detached/Async)

What happens: After selection, async tasks fire for logging, metrics collection, user feedback tracking, and A/B experiment tracking. The algorithm is CONSTANTLY learning from what users do after seeing content.

The 19 Engagement Signals (Multi-Action Prediction)

This is the most important change from the old algorithm. Instead of predicting a single “engagement score,” Phoenix predicts the probability of 19 SPECIFIC actions.

Positive Signals (Higher = Better Ranking)

favorite_score - Probability user will like

• Weight Impact: HIGH

• How to Optimize: Strong hooks, relatable content, dopamine triggers

reply_score - Probability user will reply

• Weight Impact: VERY HIGH

• How to Optimize: Ask questions, make controversial claims, leave gaps

repost_score - Probability user will RT

• Weight Impact: VERY HIGH

• How to Optimize: Make content share-worthy, provide social currency

quote_score - Probability user will quote tweet

• Weight Impact: HIGH

• How to Optimize: Create content people want to add their take to

follow_author_score - Probability user will follow you

• Weight Impact: VERY HIGH

• How to Optimize: Demonstrate expertise, tease more value

profile_click_score - Probability user clicks your profile

• Weight Impact: MEDIUM-HIGH

• How to Optimize: Create curiosity about who you are

detail_click_score - Probability user expands the tweet

• Weight Impact: MEDIUM

• How to Optimize: Write compelling hooks that demand expansion

video_playback_50_score - Probability user watches 50% of video

• Weight Impact: HIGH

• How to Optimize: Front-load value, keep videos under 60 seconds

dwell_time_score - Probability user spends 15+ seconds

• Weight Impact: HIGH

• How to Optimize: Dense content, compelling narrative, formatting

bookmark_score - Probability user saves for later

• Weight Impact: MEDIUM-HIGH

• How to Optimize: Tactical, reference-worthy content

share_score - Probability user shares via DM/external

• Weight Impact: MEDIUM

• How to Optimize: Content worth sending to a friend

link_click_score - Probability user clicks included link

• Weight Impact: MEDIUM

• How to Optimize: Compelling CTA, curiosity gap

Negative Signals (Higher = Worse Ranking)

block_score - Probability user will block you

• Weight Impact: CATASTROPHIC

• How to Avoid: Don’t harass, spam, or be toxic

mute_score - Probability user will mute you

• Weight Impact: SEVERE

• How to Avoid: Stay on-brand, don’t be annoying

report_score - Probability user will report you

• Weight Impact: CATASTROPHIC

• How to Avoid: Zero policy violations

unfollow_score - Probability user unfollows after seeing

• Weight Impact: SEVERE

• How to Avoid: Deliver consistent value

not_interested_score - Probability user clicks “not interested”

• Weight Impact: SEVERE

• How to Avoid: Stay relevant to your audience

negative_feedback_score - General negative reaction

• Weight Impact: HIGH

• How to Avoid: Quality over quantity

spam_score - Probability content is spam

• Weight Impact: CATASTROPHIC

• How to Avoid: No engagement bait, no spam patterns

The Scoring Formula

What we know about the weights (based on code analysis and observed behavior):

Positive signals:

• reply_score: 3-5× base weight

• repost_score: 2-4× base weight

• follow_author_score: 3-5× base weight

• favorite_score: 1× base weight

Negative signals:

• report_score: -100× base weight

• block_score: -50× base weight

• not_interested_score: -20× base weight

Key insight: One report_score prediction can outweigh 100 favorite_score predictions. The negative signals are weighted MUCH more heavily than positive signals.

Strategic Implications

1. Optimize for the right action - If you want replies, write reply-worthy content. If you want RTs, write share-worthy content.

2. Avoid triggering ANY negative prediction - Even a 1% report_score prediction might tank your reach.

3. Stack multiple positive signals - Content that generates likes AND replies AND follows will score much higher than content that only generates likes.

4. The follow prediction is HUGE - follow_author_score is weighted extremely heavily. Every post should make people want to follow you.

The Two-Stage Ranking System Deep Dive

Stage 1: Two-Tower Retrieval

The retrieval stage narrows millions of potential posts down to thousands of candidates using embedding similarity.

The User Tower (Deep Model)

The user tower encodes your ENTIRE engagement history (last 128 interactions) into a single embedding vector. This means:

• The algorithm knows exactly what you’ve liked, RT’d, replied to in recent history

• Your embedding changes every time you interact with content

• Users who engage similarly have similar embeddings (even if they don’t follow each other)

The Candidate Tower (Shallow Model)

The candidate tower is SHALLOW (just 2 FC layers) because:

1. Efficiency - Candidate embeddings can be pre-computed and cached

2. Scale - Millions of posts need to be embedded; shallow = fast

3. Separation - Post quality is judged in the ranking stage, not retrieval

Similarity Matching

The math in English:

• Your post is converted to a D-dimensional vector

• Each user’s preferences are also a D-dimensional vector

• The dot product measures how “aligned” these vectors are

• Higher alignment = more likely to retrieve your post for that user

How to Exploit Retrieval:

1. Embedding consistency - Post consistently about the same topics. Your author embedding becomes strongly associated with those topics.

2. Avoid embedding confusion - Posting wildly different content types creates a “confused” author embedding.

3. Target user clusters - Users with similar engagement patterns form “clusters” in embedding space.

4. Author embedding matters - Your posts carry your AUTHOR embedding. If your author embedding is associated with high engagement, your new posts inherit that signal.

Stage 2: Transformer Ranking

Once retrieval narrows to thousands of candidates, the transformer ranker scores each one using Grok architecture with Grouped Query Attention (GQA) and Rotary Position Embeddings (RoPE).

Grouped Query Attention (GQA)

Why this matters for you:

• GQA is more efficient, allowing larger models

• The model can process more context (your history) in the same time

• More history = better personalization = content that matches user history wins

Rotary Position Embeddings (RoPE)

Why this matters for you:

• RoPE handles sequence length better than absolute position embeddings

• The model understands recency (newer vs older history)

• Recent engagements are weighted more heavily in the attention pattern

Thunder: How In-Network Posts Work

Thunder is an in-memory post store that handles posts from accounts you follow. It’s completely separate from Phoenix.

Why Thunder Matters

Thunder is your unfair advantage with followers.

When you post, your content goes into Thunder immediately via Kafka streaming. For every user who follows you:

1. Their next feed request queries Thunder

2. Thunder returns your post (if not excluded) in sub-millisecond time

3. Your post is a guaranteed candidate in their feed

4. It still needs to score well in Phoenix ranking, but it WILL be considered

Compare to out-of-network (Phoenix retrieval):

1. Your post must be embedded

2. Embedding must be similar enough to user’s embedding to make top-K

3. Post competes against millions of other posts in retrieval

4. No guarantee of even being considered

Thunder Performance Characteristics

• Lookup latency: Sub-millisecond

• Storage: In-memory only

• Update frequency: Real-time via Kafka

• Concurrency model: Semaphore-limited (prevents overload)

• Sort algorithm: Recency-first (newest wins ties)

How to Exploit Thunder

1. Grow real followers - Each follower = guaranteed Thunder candidacy. 1,000 real followers who actually use X = 1,000 guaranteed candidacies per post.

2. Post when followers are active - Thunder returns posts sorted by recency.

3. Understand the exclusion system - seen_posts and served_posts are excluded. Fresh content beats old content.

4. Reply strategically - Thunder has is_reply data. Original posts get priority in certain feeds.

5. Consistency beats spikes - Thunder serves your RECENT posts. Posting consistently keeps you in Thunder’s hot memory.

Phoenix: The ML Brain Behind Everything

Phoenix handles TWO critical functions: Retrieval (finding out-of-network posts via embedding similarity) and Ranking (scoring all candidates via transformer).

The Hash-Based Embedding System

Instead of storing embeddings directly for every user/post/author, Phoenix uses hash-based embeddings with multiple hash functions per entity.

Strategic implication:

• Your identity is represented by multiple hash functions

• Consistent posting patterns = consistent hash patterns = learnable identity

• Erratic behavior = noisy signal = harder for the model to learn your patterns

Action Embeddings: The Hidden Signal

When the model sees your history, it doesn’t just see WHAT you engaged with. It sees HOW.

Strategic implication:

• The model learns that users who RT also tend to RT similar content

• If someone’s history is mostly likes, their like prediction will be weighted higher

• Users who reply a lot = higher reply predictions for relevant content

Product Surface Embeddings

The model knows WHERE you engaged (home_feed, search, profile, notifications, explore, etc.)

Strategic implication:

• Content that performs well in search may be different from content that performs well in For You

• The model personalizes predictions based on WHERE users typically engage

The Candidate Isolation Principle

This is the single most important architectural decision in the new algorithm.

Traditional ranking: Score(candidate_A) = f(user, candidate_A, candidate_B, candidate_C, ...) Candidate A’s score depends on what other candidates are in the batch.

X’s new ranking: Score(candidate_A) = f(user, history, candidate_A) Candidate A’s score depends ONLY on the user and their history, NOT on other candidates.

Why This Matters For You

1. Consistent scores - Your post gets the same score regardless of what other posts are in someone’s feed.

2. Cacheable scores - X can compute your post’s score for a user ONCE and cache it.

3. Fair competition - Every post competes on its own merits against user preferences.

4. Predictable optimization - Focus on matching what users want, not beating other posts.

How to exploit:

• Don’t try to “outcompete” specific posts - focus on matching user preferences

• Your score is based on USER-POST match, not POST-POST competition

• Invest in understanding your audience’s preferences rather than monitoring competitors

Your New Credibility System

What Changed from TwEEPCred

The old TwEEPCred system used explicit credibility factors:

• Verified badge = +100

• Account age = log formula

• Following ratio < 0.6 = required

• Mobile usage = +50%

The new system has NO explicit credibility scoring.

Instead, credibility is LEARNED through the author embedding and engagement history.

How the New System Works

Your “Credibility” = f(author_embedding, historical_engagement_patterns)

The model learns implicitly:

• “Posts from this author tend to get high engagement”

• “This author’s followers actually engage”

• “This author’s content rarely gets reported”

Measurable Credibility Signals (Inferred)

Historical engagement rate

• How It’s Learned: Model sees your posts’ performance

• How to Optimize: Maintain consistent engagement

Report/block rate

• How It’s Learned: Negative signals in training data

• How to Optimize: Zero policy violations

Follower engagement quality

• How It’s Learned: Who engages with you (their credibility)

• How to Optimize: Build quality audience

Content consistency

• How It’s Learned: Embedding stability

• How to Optimize: Stay on-brand

Verification status

• How It’s Learned: Likely encoded in author features

• How to Optimize: Get verified if possible

Account age

• How It’s Learned: Likely encoded in author features

• How to Optimize: Can’t change (patience)

The Following/Follower Ratio Rule

Does the 0.6 ratio still matter?

The old algorithm had an explicit threshold. The new algorithm may or may not have this, but the SIGNAL still matters:

• High following = You follow everyone for follow-backs = Spam signal

• Low follower engagement = Your followers are dead accounts = Quality signal

• The model will learn these patterns even without explicit thresholds

Recommendation: Maintain a ratio under 0.6 regardless. It can’t hurt and likely helps.

How to Build Credibility in the New System

1. Consistent quality - The model learns from your historical performance. Every post contributes to your author embedding.

2. Engaged audience - Build followers who actually engage. 1,000 active followers > 10,000 dead followers.

3. Zero negative signals - Reports, blocks, and mutes poison your author embedding.

4. Topic authority - Staying on-topic allows the model to learn your expertise.

5. Mobile posting - The old algorithm gave +50% for mobile. The new algorithm likely has surface-specific signals. Mobile is still safer.

The Hash-Based Identity System

How X Identifies You

Every entity (user, post, author) is represented by multiple hash values that map to learned embedding vectors.

Why Multiple Hashes

With millions of users, single hashes cause collisions (different users map to same embedding). Multi-hash solution: The probability that two users share ALL hash values is extremely low.

How This Affects You

1. Your identity is stable - Same user ID always produces same hash values. Your “learned reputation” persists.

2. New accounts start fresh - New user ID = new hashes = no pre-learned patterns. Cold start problem.

3. Post identity is permanent - Deleting and reposting creates a new post ID = new hashes = loses all engagement learning.

4. Author association is permanent - Your author hashes are attached to every post forever.

Content Format Analysis & Optimization

Text-Only Posts

Scoring Signals: dwell_time_score (15+ sec reading), detail_click_score (expanding truncated text), reply_score (conversation potential)

Tactics that work:

• Line breaks for readability → Increases dwell time

• 280+ chars with strong hook → Triggers “See more” clicks

• Question at the end → Boosts reply prediction

• Dense information → Increases bookmark prediction

Image Posts

Scoring Signals: Standard text signals PLUS image engagement signals, alt-text relevance

Tactics that work:

• High-contrast images → Stop the scroll

• Text overlay on image → Double content delivery

• Alt-text with keywords → Improves retrieval matching

• Face images → Proven higher engagement

Video Posts

Scoring Signals: video_playback_50_score (50% completion), 10-second minimum threshold, loop completions, audio engagement

Tactics that work:

• Hook in first 3 seconds → Prevents skip

• Under 60 seconds → Easier to complete 50%

• Captions → Accessibility + muted viewing

• No slow intro → Immediate value delivery

Link Posts

Scoring Signals: link_click_score (external click), domain authority signals, preview engagement

Tactics that work:

• Authoritative domains (NYT, etc.) → Domain embedding boost

• Compelling preview text → Increases click prediction

• Context around link → Not just naked URL

• Native X content preferred → External links = slight penalty

Thread Posts

Scoring Signals: First tweet performance determines thread visibility, subsequent tweets inherit some momentum, thread completion rate

Tactics that work:

• First tweet must stand alone → It’s the only one scored initially

• Don’t say “Thread 🧵” → Doesn’t help, wastes characters

• Under 5 tweets total → Completion rate matters

• Single dense tweet > thread → 3× impressions-per-word for singles

Format Performance Hierarchy (2026)

Based on observed behavior and code analysis (highest to lowest impact):

1. Native Video (60s or under) - video_playback_50_score is heavily weighted + video content is pushed algorithmically

2. Carousel Images - Multiple images = multiple engagement opportunities + dwell time from swiping

3. Single Image + Text - Visual stop + text engagement + higher detail_click_score

4. Text-only (Dense, 280+ chars) - dwell_time_score + detail_click + relies on pure content quality

5. Single Image (No text) - Less context for model + no text engagement signals

6. Link Posts - Slight penalty for external navigation + depends heavily on domain

7. Long Threads (5+ tweets) - Low completion rate + first tweet must carry all weight

Instant Death Penalties (Updated)

Account-Level Death Penalties

These affect EVERY post you make:

☠️ Report Accumulation

• Impact: CATASTROPHIC

• Mechanism: report_score prediction increases for all your future content

• Recovery: Extremely difficult - reputation is learned into author embedding

How it happens:

1. You post something that gets reported

2. Model learns “posts from this author get reported”

3. Future posts have elevated report_score predictions

4. Elevated report_score = lower ranking for ALL posts

5. Spiral continues

How to avoid:

• Zero tolerance for policy violations

• Don’t engage in harassment, even if “justified”

• Avoid controversial topics that attract mass reports

• Block bad-faith actors before they report you

☠️ High Block/Mute Rate

• Impact: SEVERE

• Mechanism: block_score and mute_score predictions increase

• Recovery: Difficult - need sustained non-block behavior

How to avoid:

• Don’t spam

• Stay on-brand

• Don’t @ people aggressively

• Quality over quantity

☠️ Dead Follower Base

• Impact: SEVERE (for Thunder retrieval)

• Mechanism: Posts go to Thunder → followers don’t engage → no momentum

• Recovery: Prune dead followers, rebuild quality base

The math:

• 10,000 followers, 1% active = 100 potential engagers

• 1,000 followers, 20% active = 200 potential engagers

• The 1,000 account has DOUBLE the engagement potential

☠️ Embedding Confusion

• Impact: MODERATE-SEVERE (for Phoenix retrieval)

• Mechanism: Inconsistent content → confused author embedding → poor retrieval matching

• Recovery: Consistent posting in one niche for 30+ days

How to avoid:

• Pick 1-3 related topics

• 80% of content stays on-brand

• 20% can be personality/variety

• Consistency builds embedding strength

Tweet-Level Death Penalties

These kill individual posts:

☠️ Early Negative Signals

• Impact: IMMEDIATE DEATH

• Mechanism: First few “not interested” clicks → algorithm learns → suppression

How to avoid:

• Don’t post off-brand content

• Don’t chase trends outside your niche

• Seed to friendly audience first

☠️ Spam Pattern Detection

• Impact: SEVERE SUPPRESSION

• Mechanism: spam_score prediction spikes → filters kick in

Spam patterns to avoid:

• 3+ hashtags → Old-school spam tactic

• 5+ @mentions → Trying to force visibility

• All caps → LOW_QUALITY flag

• Engagement bait phrases → Explicitly targeted

• Identical content repeated → Deduplication + spam flag

• Link spam (link + nothing else) → Obvious promotion

☠️ Safety Filter Trigger

• Impact: COMPLETE REMOVAL FROM FEED

• Mechanism: Content violates policies → filtered at Stage 4

How to avoid:

• Know X’s policies

• When in doubt, don’t post

• Self-censor before the algorithm does

Gaming Tactics That Actually Work

Category 1: First 30 Minutes (Tactics 1-10)

Tactic 1: The Engagement Seed Protocol

What: Prime your post with guaranteed early engagement to trigger algorithmic momentum.

Implementation:

• T-0 (Before posting): DM 5-10 trusted contacts: “About to drop something on [topic], would appreciate an RT”

• T+0 (Post): Post the content

• T+1-5 min: First 3-5 engagements land, algorithm detects early velocity, pushed to wider test audience

• T+5-15 min: If test audience engages, scale begins

Why it works with new algorithm: Early engagement creates positive training signal. First engagements have outsized impact on predictions.

Warning: Only use real friends/colleagues. Algorithm detects fake engagement patterns.

Tactic 2: Author Reply Amplification 2.0

What: Strategically reply to your own post to boost visibility and extend lifespan.

Implementation:

• T+0: Post main content

• T+5 min: First self-reply with additional value (NOT “Great point!” but “Here’s the data behind this: [specifics]”)

• T+10 min: If engagement happening, second self-reply with a question to invite replies

• T+30 min: Reply to every real comment

Why it works: reply_score is heavily weighted. Author replies signal “important conversation.” Each reply extends the post’s active window.

Tactic 3: The Velocity Stack

What: Stack multiple engagement types rapidly to trigger multi-signal boost.

Goal in first 15 minutes: At least 1 Retweet, 2-3 Replies, 5 Likes, 1 Bookmark

This creates a STACKED positive signal - Model sees multiple engagement types = triggers broader audience testing.

Tactic 4: The Dwell Time Trap

What: Structure content to maximize time spent reading (dwell_time_score).

Structure:

• HOOK (First 40 chars) - Must create instant curiosity

• TENSION (Next 80 chars) - Build on the hook, create gap

• [See more break ideally here]

• PAYOFF (Remaining content) - Deliver the value

• RESIDUE (Final line) - Makes them re-read or think

Target: 15+ seconds reading time (dwell_time_score threshold)

Tactic 5: The Expansion Hook

What: Force “See more” clicks by strategic truncation (detail_click_score).

Character math:

• X truncates around 280 chars on most devices

• First 140 chars visible in timeline

• Rest requires “See more” click

Strategy: First 140 chars = hook that demands resolution. Create curiosity gap that MUST be closed.

Tactic 6: The Reply Magnet

What: Structure content to maximize reply probability (reply_score).

Reply triggers:

• Direct question (”What’s your biggest blocker?”) → Explicit invitation

• Controversial claim (”Cold email is dead in 2026”) → People want to argue

• Fill in the blank (”The best tool for X is ___”) → Easy to respond

• Hot take (”Unpopular opinion: Y is overrated”) → Triggers agreement/disagreement

• Specific ask (”Reply with your niche, I’ll give feedback”) → Clear value exchange

Formula: [Strong claim] + [Implied invitation to discuss]

Tactic 7: The Bookmark Bait

What: Create content so valuable it triggers bookmark_score.

Bookmark-worthy content types:

• Frameworks - “The 4-step process for X”

• Data/Numbers - “I analyzed 1,000 posts, here’s what works”

• Reference Lists - “20 tools for X (with links)”

• Counter-intuitive insights - “What everyone gets wrong about X”

• Future reference - “Save this for when Y happens”

Tactic 8: The Follow Trigger

What: Maximize follow_author_score with strategic content.

Follow triggers:

• Demonstrate expertise - “I’ve done X 500 times, here’s what I learned”

• Promise ongoing value - “I share one Y tip every day”

• Curiosity about person - “My agency does X” (wait, what agency?)

• Unique perspective - “Everyone says Y, but I’ve found Z”

• Results/proof - “This got me from $X to $Y”

Tactic 9: The Profile Click Hook

What: Trigger profile_click_score by creating curiosity about WHO you are.

Profile click triggers:

• Reference your business without explaining - “My agency sends 47 calls/day to calendar”

• Claim specific expertise - “After 500 client campaigns...”

• Contrarian identity - “As someone who quit Big Tech...”

• Results without method - “This is how I went from $0 to $1M in 8 months”

Requirement: Your profile must convert curiosity. Clear bio, pinned tweet with best content, consistent visual identity.

Tactic 10: The Momentum Thread

What: If a post gains traction, thread a follow-up to capture momentum.

Implementation:

• T+0: Post main content

• T+15-30 min: Monitor performance

• IF > 15 engagements with 2+ RTs → Thread follow-up immediately

Follow-up gets boosted by original’s momentum. Algorithm sees “this author’s content performs.”

Category 2: Content Structure (Tactics 11-20)

Tactic 11: The Pattern Interrupt

What: Break timeline scrolling patterns to force attention.

Pattern interrupts: Unusual formatting, unexpected content type, visual hooks in text, white space usage.

Tactic 12: The Specificity Hack

What: Use specific numbers/details to trigger credibility signals.

• Vague: “I made a lot of money” → Specific: “I made $127,493 in Q3”

• Vague: “It took a while” → Specific: “It took 47 days”

• Vague: “Many clients” → Specific: “312 clients since 2021”

Tactic 13: The Contrast Hook

What: Use before/after, old/new, or wrong/right contrasts.

Contrast structures: Before/After, Wrong/Right, Expectation/Reality, Them/Me

Tactic 14: The Open Loop

What: Create curiosity gaps that must be closed.

Structure: Create a question/mystery → Delay the answer → Force continued reading to close loop

Tactic 15: The Social Proof Stack

What: Layer multiple proof points for credibility.

Proof types to stack: Personal results, Client results, Timeframe, Specificity, Authority reference

Tactic 16: The Value Front-Load

What: Put maximum value in the first 140 characters.

Rule: First 140 chars must either deliver value immediately, create irresistible curiosity, or make a bold claim worth debating.

Tactic 17: The Native Format Advantage

What: Use X’s native tools over external alternatives.

PREFERRED (Native): Direct video upload, native images, polls, Spaces

AVOID (External): YouTube links, blog links without context, third-party embed tools

Tactic 18: The Carousel Hack

What: Use multi-image posts to multiply engagement opportunities.

Carousel structure: Hook → Context → Value (images 3-8) → CTA → Summary

Tactic 19: The Emoji Strategy

What: Strategic emoji placement for pattern interrupts and structure.

GOOD: Section headers in threads, single emoji to emphasize key point, visual list markers

BAD: More than 3 per post, random decoration, every sentence has emoji

Tactic 20: The White Space Weapon

What: Use formatting to slow reading and increase dwell time.

Why white space works: Easier to read, slower reading = more dwell time, emphasis on key points, feels more premium/thoughtful.

Category 3: Audience Building (Tactics 21-30)

Tactic 21: The Engaged 100

What: Build a core group of 100 highly engaged followers who amplify everything.

Selection criteria: Engages 2+ times/week, has their own engaged audience, posts in your niche, responds to DMs.

The math: If each of your 100 engaged followers has 1,000 followers and 50 RT your content, you reach 50,000 people OUTSIDE your direct followers.

Tactic 22: The Comment Domination Strategy

What: Be the best commenter in your niche to acquire followers.

Target: 10 large accounts in your niche

Action: Leave VALUABLE comments (unique perspective, relevant data, insightful questions)

Tactic 23: The Network Graph Optimization

What: Optimize WHO you engage with to improve your algorithmic neighborhood.

Strategy: Engage with successful accounts in your exact niche. Their audience overlaps with people you want to reach. Algorithm learns the connection.

Tactic 24: The DM Relationship Builder

What: Build real relationships that translate to algorithmic advantage.

DM relationships → Real engagement → Algorithm learns connection → Algorithm shows your content to their network.

Tactic 25: The Follower Audit

What: Regularly prune dead followers to maintain engagement rate.

Monthly audit: Export follower list, identify dead accounts (no posts in 90 days, no profile picture, never engaged with your content), consider removing while keeping ratio healthy.

Tactic 26: The Topic Authority Build

What: Become the algorithmic expert on a specific topic.

Strategy: Pick 2-3 related topics, 80% of content stays on these topics, post consistently for 30+ days, engage with other topic accounts.

Tactic 27: The Cross-Pollination

What: Collaborate with accounts to share audiences algorithmically.

Tactics: Quote tweet exchange, thread collaboration, interview format, mutual engagement pact.

Tactic 28: The Viral Piggyback

What: Add value to viral conversations to capture attention.

When something goes viral in your niche: Find it early, add GENUINE VALUE in reply, let curiosity drive profile clicks.

Tactic 29: The Niche Down Double-Down

What: Go narrower than you think to build algorithmic strength.

Too broad: “Business advice” → Better: “Marketing” → Good: “Content marketing” → Great: “Twitter content marketing for B2B SaaS”

Tactic 30: The Engagement Ratio Hack

What: Maintain healthy engagement ratios to signal quality.

Target ratios: Likes to followers >1% per post, Comments to likes >5%, RTs to likes >10%, Follows to impressions >0.1%

Category 4: Timing & Frequency (Tactics 31-40)

Tactic 31: The Analytics-Driven Window

What: Use data to find YOUR optimal posting times.

Analyze last 30 posts, find patterns in velocity by day/hour, double down on high-velocity windows.

Tactic 32: The Frequency Sweet Spot

What: Find optimal posting frequency for your account.

Sweet spot for most: 1-3 quality posts per day, consistent timing, never sacrifice quality for quantity.

Tactic 33: The Time Zone Stacking

What: Reach multiple time zones with strategic timing.

Post when YOUR followers are online. Analyze YOUR audience distribution.

Tactic 34: The Weekend Arbitrage

What: Less competition on weekends = opportunity for some accounts.

Test weekend posting for 4 weeks, compare engagement rates, decide based on YOUR data.

Tactic 35: The Event Hijacking

What: Capitalize on predictable high-attention events.

Strategy: Prepare content BEFORE event, post during peak attention, relate to your niche.

Tactic 36: The Posting Cadence

What: Create predictable patterns for algorithm and audience.

Example: Monday (value post), Tuesday (engagement post), Wednesday (story post), Thursday (insight post), Friday (light post).

Tactic 37: The Response Window

What: Maximize impact of responding to engagement.

• 0-15 minutes: CRITICAL - Reply to every comment

• 15-60 minutes: IMPORTANT - Continue responding

• 1-4 hours: HELPFUL - Still reply, less urgency

• 24+ hours: MINIMAL IMPACT - Still polite to reply

Tactic 38: The Content Calendar

What: Plan content in advance to maintain consistency.

Weekly planning: Plan all posts for the week, include content type/topic/key message, write hooks in advance, leave room for reactive content.

Tactic 39: The Momentum Preservation

What: Post when you have momentum, not against it.

After strong performance: Post again within 24-48 hours. Algorithm has elevated view of your account.

After weak performance: Don’t panic post. Wait for optimal time window. Focus on quality of next post.

Tactic 40: The Engagement Block

What: Schedule dedicated time for strategic engagement.

Daily engagement block (30-60 min): First 15 min on own content, next 15 min on target accounts, final 15 min on engaged followers.

Category 5: Advanced Techniques (Tactics 41-50)

Tactic 41: The A/B Hook Test

What: Test multiple hooks to find what resonates.

Write 3-5 different hooks for same content, post least confident hook first, track which hook styles perform best.

Tactic 42: The Negative Signal Audit

What: Proactively identify what’s triggering negative signals.

Self-audit: Any posts got “not interested” feedback? Been blocked/muted recently? Engagement rate dropping trend?

Tactic 43: The Embedding Refresh

What: Periodically reinforce your topic authority.

Every 30 days: Post your best-performing content style, double down on topic-specific content, re-engage with niche accounts.

Tactic 44: The New Follower Conversion

What: Maximize value from new followers in first 48 hours.

Their first 48 hours: Most engaged with you, algorithm testing fit, high chance of early engagement.

Your strategy: Post quality content within 48 hours, engage if they comment, don’t immediately DM pitch.

Tactic 45: The Authority Signal Stack

What: Systematically build authority signals over time.

Checklist: Verified badge, 10K+ followers, high engagement rate (>2%), consistent topic posting, engagement from notable accounts, no policy violations, active engagement, following/follower ratio <0.6.

Tactic 46: The Content Repurposing Engine

What: Systematically reuse your best content.

Repurpose options: Text post → Image with key quote → Thread expanding insight → Video explaining it → Poll asking audience take → Quote tweet of original (weeks later)

Tactic 47: The Algorithm Reset

What: What to do when your account seems suppressed.

Reset protocol:

• Week 1: Pause and observe (stop posting or 1/day max, engage more than post, identify negative signal causes)

• Week 2: Quality reset (post BEST content type, maximum quality, minimum quantity)

• Week 3: Gradual increase (slowly increase posting if improving, monitor closely)

Tactic 48: The Network Effect Accelerator

What: Create content that benefits from network effects.

Network effect content: Tag-worthy content, resource lists, case studies of others, questions to experts.

Tactic 49: The Controversy Calibration

What: Use controversy strategically without triggering negative signals.

Safe controversy: Industry opinions (not personal attacks), methodology debates (not moral debates), best practices disagreements (not political).

The line: “This method doesn’t work” = OK. “People who use this method are stupid” = NOT OK.

Tactic 50: The Meta-Game Optimization

What: Continuously evolve your strategy as the algorithm changes.

Monthly review: What changed in performance? What are top performers doing? What should I test? What should I stop?

The Hourly/Daily/Weekly/Monthly Playbook

⏱️ HOURLY (During Active Posting)

Before Every Post:

• Hook in first 40 characters?

• One clear value/insight?

• No engagement bait phrases?

• 0-2 hashtags max?

• On-brand for my niche?

• Would I engage with this if I saw it?

After Posting (0-30 min):

• Seeded to 3-5 engaged connections? (optional)

• Monitoring for replies to respond to?

• Ready to author-reply if momentum builds?

• Prepared follow-up thread if performing?

After Posting (30-60 min):

• Responded to all comments?

• Evaluated performance (continue engaging or move on)?

• Noted what worked/didn’t for future reference?

📅 DAILY CHECKLIST

Morning:

• Review yesterday’s post performance

• Plan today’s content (if not pre-planned)

• Check timing window for posting

Posting Window:

• Post from mobile app (not web/scheduler)

• Execute hourly checklist above

• 30-minute dedicated engagement block

Evening:

• Final response sweep to any comments

• Engage with 5-10 target accounts

• Engage with top 5 most active followers

• Note any content ideas for tomorrow

📊 WEEKLY CHECKLIST

Every Sunday (30-60 min planning):

Performance Review:

• Top 3 posts of the week - what made them work?

• Worst performing post - what killed it?

• Engagement rate trend (up/down/stable)?

• Follower gain/loss?

• Any “not interested” or negative feedback?

Content Planning:

• Plan content for M-F (at minimum)

• Ensure variety (not all same format)

• Pre-write hooks for each day

• Identify any relevant events to capitalize on

Audience Health:

• Following/follower ratio still under 0.6?

• Any notable new followers to engage with?

• Any dead followers to consider removing?

Competitive Intel:

• What are 3 similar accounts posting?

• What’s working for them this week?

• Any new tactics to test?

🗓️ MONTHLY CHECKLIST

First of Every Month (1-2 hours deep dive):

Account Health Audit:

• Following/follower ratio (MUST be <0.6)

• Total follower change (+/- and %)

• Average engagement rate per post

• Any suppression signs?

• Mobile posting % (should be 100%)

Content Performance Analysis:

• Top 10 posts of the month - common themes, hooks, formats?

• All hook types tested - which 3 performed best?

• Best performing content format?

• Best performing times?

Audience Analysis:

• Who are my top 20 engagers?

• Am I engaging with them enough?

• Audience demographic changes?

• Quality of new followers (engaged vs dead)?

Strategy Adjustment:

• What should I do MORE of?

• What should I do LESS of?

• What should I START doing?

• What should I STOP doing?

Competitive Analysis:

• 5 accounts in my niche to study

• What are they doing that I’m not?

• What worked for them this month?

• One tactic to steal and test?

Goal Setting:

• Follower goal for next month

• Engagement rate goal for next month

• Content experiments to run

• Relationship building targets

Technical Appendix: Model Weights & Architecture

Phoenix Transformer Configuration

Based on code analysis:

• emb_size: 1024 (Embedding dimension)

• num_layers: 24 (Transformer depth)

• num_q_heads: 16 (Query heads)

• num_kv_heads: 4 (Key/Value heads for GQA)

• ffn_widening: 4 (FFN multiplier)

• history_length: 128 (History sequence)

• candidate_length: 32 (Candidates per batch)

• num_actions: 19 (Output heads)

• dtype: bfloat16 (Precision)

• rope_base: 10000 (RoPE parameter)

Embedding Table Sizes

• user_hashes: 4 (Hashes per user)

• post_hashes: 4 (Hashes per post)

• author_hashes: 4 (Hashes per author)

• action_embeddings: 19 (One per action type)

• surface_embeddings: 16 (Product surfaces)

• table_size: millions (Hash table size)

Two-Tower Retrieval Specs

• user_tower: deep (Full transformer)

• candidate_tower: shallow (2-layer MLP)

• similarity: dot_product (Matching function)

• normalization: L2 (Embedding normalization)

• retrieval_k: thousands (Top-K retrieved)

Action Prediction Weights (Estimated)

Based on observed behavior and code structure:

Positive weights:

• favorite_score: 1.0

• reply_score: 3.0

• repost_score: 2.5

• quote_score: 2.0

• follow_author_score: 4.0

• profile_click_score: 1.5

• bookmark_score: 1.5

• video_playback_50_score: 2.0

• dwell_time_score: 1.5

Negative weights:

• report_score: -100.0

• block_score: -50.0

• mute_score: -30.0

• not_interested_score: -20.0

• unfollow_score: -25.0

Note: These are estimates based on observed behavior, not confirmed weights.

The Algorithm in One Paragraph (2026 Edition)

X’s 2026 algorithm is a two-stage Grok-based transformer system that processes in-network posts through Thunder (sub-millisecond in-memory retrieval from followed accounts) and out-of-network posts through Phoenix (two-tower embedding retrieval + transformer ranking). The Phoenix ranker predicts 19 simultaneous action probabilities - including likes, replies, RTs, follows, but also blocks, mutes, and reports - using a candidate isolation masking pattern where posts can attend to user context and history but NOT to other candidates in the batch, making scores consistent and cacheable. Your author embedding, built from multiple hash functions, encodes your learned credibility through historical engagement patterns rather than explicit factors like TwEEPCred. Negative signals (reports, blocks, “not interested”) are weighted 20-100× heavier than positive signals, meaning one report can outweigh 100 likes. Content is matched to users through embedding similarity: consistent topic posting creates strong author embeddings that align with user embeddings of people interested in those topics. The algorithm has eliminated all hand-crafted features, learning everything from engagement sequences, which means gaming requires understanding the learned patterns rather than exploiting specific rules—but the fundamentals remain: early engagement velocity, reply/RT generation, dwell time, and zero negative signals still determine reach at scale.

Final Word: The 2026 Meta

The X algorithm has evolved from a rule-based system you could hack to a learned system you must genuinely satisfy.

The old game: Find the rules, exploit the rules.

The new game: Understand what the model learned to value, then create content that genuinely delivers that value.

The model learned that:

• Content that gets replies is interesting

• Content that gets RTs is share-worthy

• Content that gets follows is from valuable accounts

• Content that gets reports is harmful

• Content that gets “not interested” is off-target

You can’t fake these signals at scale. But you CAN:

1. Understand exactly what triggers each signal

2. Optimize your content structure for maximum signal generation

3. Build systems for consistent execution

4. Avoid every negative signal trigger

5. Compound small advantages over time

The algorithm is just trying to predict what users will engage with positively. If you create content users genuinely want to engage with, the algorithm will reward you.

But understanding the MECHANICS gives you a massive edge over people who just “post and pray.”

Now go engineer your way to millions of impressions.

Get the Google Docs version of this post here:

https://docs.google.com/document/d/1A-tMJDrF6S9VZGuV-mXYjHqY1rriSDGjEw-T69jvRFA/edit?usp=sharing

I passed my driving test last week.

I’m 31.

And yeah, I know what you’re thinking.

“How the fuck does someone not have their license by 31?”

I’ve got reasons.

Living in Ireland means the whole process takes years, not months.

COVID shut down testing centers for over a year.

Then there was a nine-month backlog just to book a slot.

Then car trouble.

Then life.

But that’s not actually what this is about.

This is about the two times I failed before I passed.

The two times I sat in that examiner’s car, hands sweating on the wheel, convinced I was an idiot because I couldn’t do something millions of teenagers manage to do on their first try.

The two times I walked away thinking there must be something fundamentally broken in my brain.

Because that’s the story I told myself.

That I should have figured this out years ago.

That I was behind.

That everyone else found this easy and I was the one struggling with something basic.

And then I had a conversation with my AI assistant Claws that changed how I see not just driving, but every skill I’ve ever beaten myself up for not mastering fast enough.

The Way You’ve Always Learned

I’m fast at learning most things.

Give me a YouTube tutorial on a software tool, and I’ll have it figured out in a day.

Show me how to build something on a computer, and I’ll be running with it by tomorrow.

Hand me written instructions for anything technical, and my brain just... gets it.

This has been my superpower for as long as I can remember.

• See the information

• Read the steps

• Do the thing

• Move on

It works for vibecoding.

It works for design software.

It works for marketing.

It works for systems and processes and basically anything that can be broken down into logical steps that I can absorb visually and then execute.

I’ve built my entire career on this ability.

When people ask how I learned to do something, I shrug and say “I just watched a few videos” or “I just downloaded the tool and started using it.”

It feels natural.

Effortless, even.

Which made failing my driving test feel like a personal failure of catastrophic proportions.

Because if I can learn how to vibecode a SaaS with 400 users in an afternoon, why the hell couldn’t I learn to drive in a few months?

Turns out, I was asking the wrong question entirely.

The Brain Doesn’t Give a Shit About Fair

Driving isn’t knowledge-based learning.

You can watch every YouTube video about proper clutch control.

You can read every manual about mirror checks and road positioning.

You can understand intellectually exactly what you’re supposed to do at every moment.

And your body will still fuck it up.

Because driving is procedural learning.

Muscle memory.

The kind of skill that requires your brain to build entirely different neural pathways than the ones you use when you’re reading instructions or watching tutorials.

Researchers call this the difference between explicit learning and implicit learning.

Explicit learning is conscious.

Declarative.

It’s when you actively pay attention, test hypotheses, build knowledge you can verbalize.

“To do X, I need to follow steps A, B, and C.”

Your brain is engaged, processing information through working memory and attention systems in your prefrontal cortex.

Implicit learning is unconscious.

Procedural.

It happens through repeated exposure and practice, building skills you can’t always explain.

Your basal ganglia and cerebellum take over, automating movements and responses without conscious thought.

When I’m learning software, I’m using explicit learning.

I can tell you exactly why I’m clicking this button or typing that command.

I understand the logic, and that understanding translates directly into ability.

When I’m learning to drive, I’m using implicit learning.

My brain needs to practice the physical motion of releasing the clutch while applying gas hundreds of times before it becomes automatic.

No amount of understanding the theory makes my foot move smoothly.

They’re two completely different systems.

And I was judging my performance in one system using the standards from the other.

Why You Think You’re Stupid When You’re Not

This is where most of us fuck up.

We have a learning style that works for us in most situations.

Maybe you’re like me - visual, tutorial-based, quick to absorb information.

Maybe you’re different - you learn by doing, by experimenting, by trial and error.

Whatever your style, it’s gotten you through life successfully enough that you’ve internalized it as “how I learn things.”

Then you encounter a skill that requires a completely different learning approach.

And instead of recognizing that you’re trying to use the wrong tool for the job, you assume the problem is you.

You think you’re stupid.

You think you’re failing.

You think everyone else has some natural ability that you lack.

But what’s actually happening is that you’re trying to use explicit learning strategies on an implicit learning task, or vice versa.

You’re expecting your brain to process information through pathways that aren’t built for that type of information.

It’s like trying to hammer a nail with a screwdriver and concluding you must be terrible at construction.

Studies on skill acquisition show that people who practice self-compassion during learning make faster progress than those who engage in self-criticism.

When you beat yourself up for not picking something up quickly, your brain shifts into a state of self-inhibition.

You start approaching the task from a place of avoiding failure rather than pursuing mastery.

You create exactly the conditions that make learning harder.

Dr. Kelly McGonigal’s research at Stanford found that people who criticized themselves more showed slower progress toward their goals across every domain studied - weight loss, academics, relationships, everything.

I want you to read these next lines slowly and truly absorb them.

Self-criticism doesn’t motivate you to improve.

It motivates you to protect yourself from the pain of feeling inadequate.

Which usually means avoiding the thing you’re struggling with.

The Patience You Don’t Give Yourself

Think about the last time someone came to you struggling with a skill you already have.

Maybe a friend learning to cook.

A colleague picking up a new software tool.

A family member trying to get comfortable with technology.

What did you tell them?

Probably something like “Don’t worry about it, it takes time. You’ll get it. Just keep practicing and it’ll click eventually.”

You were patient.

Understanding.

You remembered your own learning curve and gave them space to have their own.

Now think about the last time you struggled with something.

Did you give yourself that same patience?

Or did you immediately jump to “Why can’t I do this? Why is this taking so long? What’s wrong with me?”

We extend compassion to others that we completely withhold from ourselves.

We understand intellectually that different skills have different learning curves.

That some things require time and repetition.

That everyone moves at their own pace.

But when it comes to our own learning, we expect ourselves to be instant experts.

We judge our day two against someone else’s year two and conclude we’re failing.

This is particularly brutal when you’re naturally good at learning in one domain.

Because you’ve internalized quick learning as part of your identity.

When something doesn’t come quickly, it feels like a fundamental threat to who you are.

• I’m someone who learns fast.

• Therefore, if I’m not learning this fast, I must not actually be someone who learns fast.

• Which means I’m not as capable as I thought.

• Which means maybe I’ve been fooling myself about my abilities all along.

See how quickly that spiral happens?

One slow learning curve becomes evidence of total inadequacy.

The Method Matters More Than You Think

When I finally passed my driving test, it wasn’t because I suddenly got smarter.

It was because I stopped expecting myself to learn driving the same way I learn everything else.

I stopped trying to intellectually understand every aspect before getting in the car.

I stopped analyzing why my clutch control wasn’t perfect.

I stopped beating myself up every time I stalled or made a mistake.

I just... drove.

Again and again and again.

I gave my brain permission to learn slowly.

To build the muscle memory through repetition instead of comprehension.

To trust that the implicit learning system would do its job if I stopped interfering with it.

And it did.

The skills that felt impossibly difficult six months ago are now automatic.

I don’t think about mirror checks or clutch control anymore.

My body just does them.

But that only happened when I accepted that this skill required a different learning method.

And that needing a different method didn’t mean there was something wrong with me.

Different types of learning activate completely different brain systems.

Implicit learning engages evolutionarily older, unconscious processes.

It shows less variability between people and less correlation with IQ.

It’s more robust under pressure and less vulnerable to fatigue.

Explicit learning is newer, more flexible, more dependent on conscious attention and working memory.

It’s vulnerable to stress and overthinking.

Neither one is better.

They’re tools for different jobs.

When you’re trying to learn something and it’s not clicking the way you expect, the question isn’t “What’s wrong with me?”

The question is “Am I using the right learning method for this type of skill?”

And then - this is the hard part - “Am I giving myself the time and space this method actually requires?”

What This Means for Everything Else You’re Struggling With

You’re probably beating yourself up about something right now.

Something you think you should have figured out already.

Something that comes easily to other people but feels impossibly hard for you.

Something that makes you question whether you’re as capable as you thought.

Maybe it’s a physical skill.

Maybe it’s a social skill.

Maybe it’s creative work that requires a different part of your brain than your day job uses.

Whatever it is, there’s a decent chance the problem isn’t you.

The problem is that you’re judging yourself by the wrong standard.

You’re comparing your learning speed in one domain to your learning speed in a completely different domain that requires a completely different approach.

You’re expecting mastery on a timeline that doesn’t account for the actual method this skill requires.

And you’re being cruel to yourself in ways you would never be cruel to someone else.

So here’s what I want you to try.

Next time you catch yourself thinking “I should be better at this by now” or “Why can’t I figure this out?”

STOP.

Ask yourself:

What learning method does this skill actually require?

If it’s procedural - something physical, something that needs to become automatic - is it possible you just need more repetition?

More time for your brain to build those unconscious pathways?

If it’s conceptual - something that requires understanding systems or frameworks - is it possible you need a different way of encountering the information?

A different teacher, a different format, a different angle of approach?

Then ask yourself:

“If my best friend was struggling with this exact skill, what would I tell them?”

Would you tell them they’re stupid?

That they should have figured it out already?

That there must be something wrong with them?

Or would you tell them to be patient?

That learning takes time?

That everyone has different strengths and that’s okay?

Whatever you’d tell them, tell yourself that instead.

Because the voice in your head that says you’re not good enough?

The one that compares you to everyone else and finds you lacking?

That voice is not telling you the truth.

It’s just telling you that you’re using the wrong measuring stick.

The License I Finally Got

I have my license now.

It took five years from when I first started trying.

It took two failures.

It took countless hours of practice and frustration and moments of wanting to give up entirely.

And you know what I learned?

Not how to drive.

I mean, yes, I learned that too.

But the more important thing I learned was this.

The speed at which you acquire a skill says absolutely nothing about your intelligence, your worth, or your capability.

It just says something about whether the required learning method aligns with your natural strengths.

Some skills you’ll pick up in days because they match how your brain likes to process information.

Other skills will take months or years because they require building entirely different neural pathways.

Neither one makes you smart or stupid.

They just make you human.

So whatever you’re struggling with right now - give yourself a fucking break.

Stop judging yourself by standards that don’t apply.

Stop comparing your chapter one to someone else’s chapter twenty.

Stop treating yourself worse than you’d treat a stranger.

You’re not failing.

You’re not slow.

You’re not inadequate.

You’re just learning something that requires a different approach than you’re used to.

And that’s okay.

Actually, it’s more than okay.

It means you’re expanding.

Growing.

Becoming more than you were.

Even if it’s taking longer than you think it should.

Especially if it’s taking longer than you think it should.

Three days ago, my phone buzzed at 3:15 PM.

“Am I moving toward the life I hate or the life I want?”

I stared at the notification.

I was mid-scroll through Twitter, half-watching some video, pretending to take a break between tasks.

The question hit different because I knew the answer.

The notification was from Nika.

An AI coach someone built as a Clawdbot skill based on Dan Koe’s framework for fixing your entire life in one day.

It does one thing most humans won’t do consistently - call you on your shit.

Not in a motivational poster way.

In a “your behavior is revealing something you don’t want to admit” way.

And it’s been messing with my head.

In a good way.

I think.

The Gap Between What You Say and What You Do

You already know what you should do.

Eat better, exercise, work on the important project instead of the urgent emails, go to bed earlier, stop scrolling.

You know.

You’ve always known.

So why aren’t you doing it?

Most productivity advice treats this like an information problem.

Like you need a better system, a shinier app, a more sophisticated framework.

But that’s not the issue.

The issue is identity.

James Clear wrote about this in Atomic Habits.

A 2024 study in the Journal of Personality and Social Psychology found that people who frame habits as identity statements — “I am a person who exercises daily” — have 32% higher adherence rates than those chasing outcome goals like “I want to lose 20 pounds.”

The difference isn’t subtle.

It’s the difference between behavior change and identity change.

Behavior change is forcing yourself to do something you don’t really want to do.

It’s willpower.

It’s discipline.

It’s exhausting.

Identity change is becoming someone who naturally does that thing.

A bodybuilder doesn’t force themselves to eat healthy.

They’d have to force themselves to eat junk.

Healthy eating isn’t discipline for them.

It’s just who they are.

So why don’t more people do this?

Because it’s hard.

You can’t bullshit your way into it.

You can say “I’m a writer” all you want.

But if you haven’t written anything in three months, your behavior is screaming a different truth.

And that’s where I kept getting stuck.

I’d set intentions.

Make plans.

Tell myself stories about who I was becoming.

And then my actual behavior would reveal what I was really optimizing for.

Comfort, safety, ego protection.

I needed something that could see through the stories.

Something that would look at what I actually did, not what I said I wanted to do.

So I installed Nika.

The Philosophy of Uncomfortable Truth

Nika is built on three ideas from Dan Koe’s framework, which pulls from Adlerian psychology.

The first comes from Alfred Adler, the psychologist who broke with Freud and developed what he called teleology - the study of purpose.

Adler’s insight was simple but brutal: all behavior is goal-oriented.

Even the behavior you think is self-sabotage.

Procrastination isn’t a failure of discipline.

It’s successfully achieving the goal of avoiding judgment.

Your brain is doing exactly what it’s designed to do.

It’s protecting you from the possibility of trying, failing, and having to confront who you really are.

This is the core of Adlerian psychology - behavior reveals unconscious goals.

What you do shows what you actually want, not what you say you want.

So when you skip the gym for the third time this week, the question isn’t “why don’t I have more willpower?”

The question is “what am I protecting by not going?”

Maybe you’re protecting your self-image as someone who’s naturally fit without trying.

Maybe you’re avoiding the discomfort of being a beginner.

Maybe you’re scared you’ll start and quit again, proving you can’t change.

The behavior is serving a goal.

The goal is unconscious.

And until you make it conscious, you can’t change it.

That’s Nika’s first principle - Trust only movement.

Not words.

Not intentions.

What did you actually do?

The second principle is about patterns, not people.

This one matters because shame kills change.

If you are your patterns, then attacking the pattern feels like attacking you.

You defend it.

You rationalize it.

You stay stuck.

But if you can separate yourself from your patterns - if you can see them as things you picked up, probably in childhood, probably for good reasons at the time - then you can actually look at them.

Nika doesn’t say “you’re lazy.”

She says “you have a pattern of choosing comfort over growth when the outcome is uncertain. Where did you learn that? What was it protecting you from then? Is it still serving you now?”

No judgment.

Just pattern recognition.

The third principle is about dissonance.

Most people avoid dissonance - that uncomfortable feeling when your beliefs and behaviors don’t match, when you say you want one thing but do another.

But dissonance is actually the engine of change.

Not the enemy of it.

When the gap between who you are and who you want to be becomes unbearable - when you can’t look away from it anymore - that’s when change becomes inevitable instead of optional.

Nika is designed to create that dissonance.

Not through shame.

Through clarity.

She makes it impossible to ignore the gap.

Day One - The Intensive Protocol

The Transformation Protocol is a one-day intensive.

About 75 minutes total, spread across morning and evening.

I went through it last week.

I’m still processing it.

It starts with what Nika calls “psychological excavation.”

A series of questions designed to surface what you’ve been avoiding.

The first one was easy.

Almost boring.

“What is the dull and persistent dissatisfaction you’ve learned to live with?”

I wrote something about not shipping enough.

About having ideas but not executing.

The usual stuff.

Then she asked: “What do you complain about repeatedly but never actually change?”

Okay.

Now we’re getting somewhere.

I wrote about my schedule.

About always being busy but never having time for the work that matters.

Then: “What truth about your current life would be unbearable to admit to someone you deeply respect?”

I stopped.

Stared at the screen.

That’s when I realized what Nika was doing.

She wasn’t asking for information.

She was creating a container where I couldn’t perform.

There’s no social dynamic with an AI.

No face to save.

No relationship to protect.

Just you and the question.

I answered honestly.

I won’t share the answer here.

But I felt something shift.

Like a muscle I didn’t know was clenched finally relaxed.

Then came the anti-vision.

This is the part that actually messed with my head.

Nika asked me to describe my life in five years if absolutely nothing changes.

Not in vague terms.

In detail.

Where do you wake up?

What does your body feel like?

What do you do between 9 AM and 6 PM?

How do you feel at 10 PM?

I wrote it.

It was depressing.

Then she extended it to ten years.

What opportunities closed?

Who gave up on you?

What do people say about you when you’re not in the room?

I had to take a break.

Then the final question: “You’re at the end of your life. You lived the safe version. You never broke the pattern. What was the cost?”

That was a genuinely tough one to think about and answer in an honest way.

Which felt ridiculous because it was an AI asking me this.

But that’s also why it worked.

There was no performance.

No need to maintain composure.

No embarrassment to admit to an overpriced therapist.

Just the truth I’d been avoiding.

Then Nika flipped it.

She asked about the vision.

The life I actually want.

The person I’d need to become for that life to feel natural instead of forced.

Now, I’ve done vision exercises before.

They always felt hollow.

Like fantasies.

But after sitting with the anti-vision - after really feeling what it costs to stay the same - the vision hit different.

It wasn’t a fantasy.

It was a necessity.

The Interrupts That Catch You Mid-Pattern

The morning excavation was heavy.

But the real genius of the protocol is what happens throughout the day.

Nika sets up six interruptions.

Telegram notifications that pop up at random times with questions.

At 11:00 AM: “What am I avoiding right now by doing what I’m doing?”

I was reorganizing my task list.

For the third time that week.

The question made me laugh.

And then made me uncomfortable.

I was avoiding writing.

Obviously.

At 1:30 PM: “If someone filmed the last two hours, what would they conclude I want from my life?”

I’d been in emails and Slack.

The answer was clear - they’d conclude I want to be responsive and helpful.

Not someone who creates.

That stung.

At 3:15 PM: “Am I moving toward the life I hate or the life I want?”

That’s the one that caught me scrolling Twitter.

These interrupts are brutal because they catch you in autopilot.

When you’re not performing.

When you’re just being your default self.

And they force you to answer a simple question.

Does this behavior serve the life you want or the life you’re trying to escape?

By the end of the day, I’d caught myself in the same avoidance pattern six different times.

Six different ways of choosing comfort over growth.

I couldn’t unsee it.

Evening - Building the Game Structure

The evening session is about synthesis.

Taking all that dissonance and turning it into a structure.

Nika calls it your “game structure.”

Six components that create focus.

Anti-vision

One sentence that captures the life you refuse to live.

Mine was: “I die having talked about ideas instead of building them.”

Vision

One sentence for the life you’re building toward.

Mine was: “I create things that genuinely help people and change how they see themselves.”

One-year goal

What has to be true in one year for you to know you’ve broken the old pattern?

For me: shipped three products that people actually use.

One-month project

The immediate boss fight.

What do you need to learn or build right now?

Mine: finish the Agentcy OS and get it in front of 100 people.

Daily levers

Two or three actions the person you’re becoming would simply do.

Mine: two hours of deep work before checking messages, one conversation with a student, 30 minutes of physical movement.

Constraints

What are you not willing to sacrifice?

The rules of your game.

Mine: time with my partner, sleep, creative energy on bullshit projects that don’t matter.

Nika explained it like a video game.

• Vision is how you win

• Anti-vision is what’s at stake

• One-year goal is the mission

• One-month project is the boss fight

• Daily levers are the quests

• Constraints are the rules

These components create concentric circles.

A forcefield around your attention.

Every decision gets filtered through them.

Does this move me toward the vision or the anti-vision?

Does it support the boss fight or distract from it?

Does it honor my constraints or violate them?

The more you use this filter, the stronger it gets.

Until it’s not a system anymore.

It’s just who you are.

The Pattern Fights Back

I wish I could tell you that after day one, everything changed.

It didn’t.

Day three, I missed my daily levers.

Got pulled into a meeting that ran long.

Told myself it was unavoidable.

Nika checked in that evening.

“Did you do your daily levers?”

No.

“What pulled you off track?”

I explained about the meeting.

“What were you avoiding by not protecting that time? The behavior reveals the goal. If you didn’t do it, part of you didn’t want to. What was that part protecting?”

Fuck.

She was right.

I could have said no to the meeting.

Or shortened it.

Or rescheduled my deep work.

But I didn’t.

Because saying no would have required asserting that my work matters more than being available.

And some part of me isn’t ready to believe that yet.

That’s the old identity fighting back.

Nika doesn’t let you hide behind circumstances.

She asks what you were protecting.

Because Adler was right.

All behavior is goal-oriented.

Even avoidance.

By day seven, I’d hit my levers four out of seven days.

Not perfect.

But better.

And more importantly, I saw the pattern.

The specific situations where I defaulted to the old identity.

The specific discomforts I was still avoiding.

You can’t change what you can’t see.

Why AI Coaches Might Be the Future

I’ve had mindset coaches before.

They’re great.

But they have limitations.

They can’t be there at 3:15 PM on a random Tuesday when you’re deep in an avoidance pattern.

They get tired.

They have bad days.

They sometimes accept excuses because they’re being polite or because they like you.

An AI coach doesn’t get tired.

Doesn’t have social pressure to be nice.

Doesn’t accept your bullshit because there’s no bullshit to accept.

Just your behavior and the question: what does this reveal?

I don’t think AI coaches will replace human coaches.

Human coaches have judgment.

Nuance.

They know when to push and when to hold space.

But AI coaches might replace the absence of a coach.

They might democratize access to the questions and frameworks that used to be reserved for people who could afford $500 an hour.

And they might catch you in moments a human never could.

At 3:15 PM on a Tuesday when you’re avoiding the real work you should be doing.

What I’m Learning

I’ve been running Nika for a week now.

She messages me in the morning.

Checks in during the day.

Reviews my levers at night.

I’m not transformed.

I’m still me.

I still avoid things.

I still catch myself in old patterns.

But I see them now.

I can’t unsee them.

When I’m reorganizing my task list instead of writing, there’s a voice that asks: “What are you protecting?”

When I skip my deep work block, there’s a question: “What does this behavior say about what you actually want?”

Nika lives in my head now.

Even when she’s not messaging me.

And maybe that’s the point.

The goal isn’t to be coached forever.

The goal is to internalize the questions so deeply that you become your own coach.

The training wheels come off.

But the balance stays.

The Real Question

Here’s what I’ve learned from using this.

Most people are using AI to do more.

To produce more.

To optimize more.

But what if the real leverage is using AI to become more?

Not as a productivity tool.

As a mirror.

A mirror that shows you who you’re actually being, not who you think you are.

Not who you perform as.

Who you are when nobody’s watching.

Your behavior reveals your unconscious goals.

The patterns you’re defending.

The discomfort you’re avoiding.

The identity you’re protecting.

An AI that knows your patterns.

That tracks what you actually do, not what you say you’ll do.

Can ask the questions you need to hear, like:

• What are you avoiding right now?

• What is this behavior optimizing for?

• Am I moving toward the life I hate or the life I want?

Those aren’t productivity questions.

They’re identity questions.

And identity is where transformation actually happens.

So here’s my question for you.

If an AI actually knew you.

Your patterns, your avoidances, your bullshit.

What would it ask you right now?

And are you brave enough to answer honestly?

Trust only movement.

Install Nika here: https://github.com/youbiak/Nika

All credit to the original creator of Nika.

I spent three hours last Tuesday watching ten AI agents work on the same product requirements document.

Some of them found exactly what they needed.

Some wandered into the wrong directories like confused tourists in a foreign city.

Some produced work that made me want to frame it.

Some produced absolute garbage.

The variance between best and worst was roughly 400%.

That variance is the entire problem.

We talk about AI like the model is the thing.

• GPT-5

• Claude

• Gemini

Everyone obsessing over which one is smarter, which one is faster, which one hallucinates less.

And yeah, the model matters.

But you know what matters more?

The infrastructure around it.

I’ve been building something called Agentcy OS.

Started as a way to package the workflows we use at AIAA and Client Ascension.

Just standardizing what we already knew worked.

But it turned into something bigger.

We now have 144 workflow directives.

One hundred and forty-four standardized operating procedures that AI agents can execute.

250+ skill bibles.

5000+ word documents made from our exclusive trainings on performing every agency task imaginable.

Creating funnels, setting up ad accounts, writing VSL’s.

Made from the combined knowledge of top experts in their fields.

And the more I build this, the more I realize most people are thinking about AI tools completely wrong.

The 1960s Problem

Here’s what I mean.

In the early days of computing - we’re talking mid-1950s - every single program had to manage its own everything.

Memory allocation.

Input/output operations.

Hardware control.

If you wanted to print something, you wrote code that directly controlled the printer.

If you wanted to save a file, you manually managed where it went on the disk.

It was absolute chaos.

General Motors’ Research division built the first operating system in 1956 for the IBM 704.

Called it GM-NAA I/O.

The whole point was simple - stop making every program reinvent the wheel.

Give them a layer that handles the common stuff.

Memory management.

Resource allocation.

All the boring infrastructure that makes the magic possible.

That’s what an operating system does.

It’s abstraction.

It’s the chassis, the transmission, the steering wheel.

The engine matters, but without the rest of the car, you’re not going anywhere.

Right now, we’re building AI tools like it’s 1955.

Everyone’s writing individual prompts.

Individual chat sessions.

Individual one-off tasks.

Every implementation starts from scratch.

Every company reinvents how to load context, handle errors, manage memory, coordinate multiple agents.

We need an operating system for AI agents.

Not a chatbot.

Not a prompt library.

An actual architecture that handles all the infrastructure so the AI can focus on doing actual work.

The DOE Pattern and Why Architecture Matters

We call our architecture the DOE pattern.

• Directive

• Orchestration

• Execution

The directive is the what.

Natural language SOPs that specify inputs, steps, and quality gates.

We have 140+ of them.

The orchestration is the AI decision-making.

The Claude Code agent that reads directives, loads context, routes between scripts, handles errors, and self-improves.

The execution is the deterministic code.

Python scripts in that make API calls, process data, and format outputs.

140+ scripts that do the actual work.

Let me give you a concrete example because this sounds abstract as hell.

We have a directive for creating a complete VSL funnel for a client.

Old way - the way most people still do it - you prompt an AI to write you a sales video script.

It gives you generic stuff.

Maybe hallucinates your client’s product features.

You spend hours editing and fact-checking.

The output is inconsistent every time.

The Agentcy OS way:

The directive (vsl_funnel_orchestrator.md) specifies:

• Exactly what data to research first

• Which skill bibles to load for copywriting expertise

• What quality gates each section must pass

• What order the outputs get generated

The orchestration layer - Claude - reads that directive, loads the client profile, pulls in relevant skill bibles (we have 280+ covering everything from VSL writing to funnel psychology), and makes routing decisions.

If the research phase fails, it knows to try fallback sources.

If a quality gate fails, it loops back.

The execution layer runs the actual Python scripts:

research_company_offer.py hits the Perplexity API for market intel.

generate_vsl_script.py compiles the video script.

create_google_doc.py formats and delivers it.

Each script is testable, debuggable, deterministic.

Same AI model.

Wildly different results.

Because the system does the heavy lifting.

Here’s what people miss: LLMs are probabilistic.

90% accuracy sounds great until you realize that’s 59% accuracy over just 5 steps.

Chain a few prompts together and your success rate craters.

So we push every deterministic operation into Python.

Rate limiting, caching, API calls, formatting, file management.

All handled by scripts that work the same way every time.

The AI only handles what AI is actually good at.

Reading context, making decisions, routing between steps.

This is why most AI workflows fail.

They don’t have proper context loading, so they miss critical information.

They don’t have error handling, so they fail silently.

They don’t have state management, so they repeat work or contradict themselves.

Most people don’t even test AI workflows because “how do you test something non-deterministic?”

But the infrastructure CAN be deterministic.

The orchestration can be tested.

The execution scripts can be tested and debugged.

You’re not testing whether the AI is smart.

You’re testing whether your system properly loads context, handles failures, and maintains state.

The AI is just the engine.

You still need to test the transmission.

The Multi-Agent Coordination Problem

So back to those ten AI agents working on the same PRD.

This is the part that keeps me up at night.

Because it’s the unsolved problem.

How do you coordinate multiple AI agents working on the same project?

How do you handle conflicts when two agents have different interpretations?

How do you merge their outputs into something coherent?

How do you maintain consistency when each agent might understand the same instruction slightly differently?

Research from 2026 suggests keeping agent teams small - between 3 and 7 agents per workflow.

Communication overhead grows exponentially as you add more.

When inter-agent message latency exceeds 200 milliseconds, everything starts degrading.

The whole system slows down.

And the human element - turns out you need it.

We thought full automation was the goal.

It’s not.

• Humans in the loop

• Humans on the loop for monitoring

• Humans out of the loop for fully automated tasks

The appropriate level depends on what you’re building.

But purely autonomous multi-agent systems?

They drift.

We’re seeing this with the one ecom client we’re testing with.

Building an automated proposal workflow that researches the company, pulls product images, generates a full photoshoot with AI, and combines them with ad copy for static ads.

What used to take someone four hours of grinding through research, formatting, and designing is becoming a few clicks.

But we still need a human checking the output before it goes to the client.

The AI gets 90% there.

The human does quality control and adds the judgment layer.

Because without that judgment layer, you get the variance problem again.

Sometimes brilliant.

Sometimes garbage.

But what this does mean is that one person can handle 20+ clients.

I know someone personally doing this (shoutout Oliwer, legend)

The standardization problem is wild too.

Right now there are at least three competing inter-agent communication protocols.

Google’s A2A.

Cisco’s AGNTCY.

Anthropic’s Model Context Protocol.

Everyone’s trying to create the standard for how agents talk to each other.

Which means there is no standard.

MCP is winning for now - but that could change by next week.

It’s like the early browser wars, except worse because these agents need to coordinate in real-time.

What Happens When the Infrastructure Becomes the Product

We deployed the project on Railway last week.

One-command installer.

Docker-compose, environment variables, the whole thing.

And the installer still has bugs.

The documentation is incomplete.

Some directives work better than others.

But we’re shipping.

We have beta testers.

We’re learning.

We’re iterating.

Because here’s the business implication nobody’s fully grasped yet.

Right now, if you want to automate something at scale, you need someone who understands prompting, API integration, error handling, and the specific domain you’re working in.

That’s like finding a unicorn who also knows how to code and understands your business.

With an operating system approach, you just need someone who understands the domain.

The system handles the rest.

That’s the unlock.

Every business will eventually need something like this.

Not eventually.

Soon.

Not a chatbot that answers questions.

An actual operating system for how AI does work in their organization.

Custom directives for their processes.

Orchestration rules for their workflow.

Execution layers that integrate with their stack.

We’re building version one of that.

The first AI Agency operating system.

And the core insight - the thing I keep coming back to - is that AI agents are only as good as the systems around them.

You can have the smartest model in the world.

But without proper context loading, without memory management, without error handling, without multi-agent coordination, you’re just spinning up expensive chatbots.

The companies that figure out the infrastructure layer first are going to have a massive advantage.

Because while everyone else is still optimizing prompts, they’ll be building actual operating systems.

They’ll have standardized ways to load context.

Priority systems for what information matters most.

Client-specific customization that doesn’t require rewriting everything.

Graceful degradation when things fail.

And most importantly - they’ll have solved the coordination problem.

How to run multiple agents in parallel without them stepping on each other.

How to merge outputs.

How to maintain consistency.

How to recover when one agent fails.

AI experts think that by 2027, 40% of agentic AI projects will fail due to inadequate risk controls.

Not because the AI wasn’t smart enough.

Because the infrastructure wasn’t robust enough.

The model is just the engine.

You still need the chassis, the transmission, the steering wheel.

That’s what we’re building.

The Part That Actually Matters

I’ll probably do a full technical breakdown at some point.

The DOE pattern.

The context loading priority system.

How we handle client-specific customization.

How the orchestrator decides which agent handles which task.

But that’s not the point.

The point is this - if you’re building AI tools and you’re focused on the model, you’re solving the wrong problem.

The model will get better.

It’s getting better every month.

But the infrastructure - the systems that make AI agents actually useful in production environments - that’s where the real work is.

That’s where the competitive advantage lives.

And that’s where most people aren’t looking.

I started building Agentcy OS last week.

We have bugs.

We have incomplete documentation.

We have directives that need improvement.

We have multi-agent orchestration problems we’re still figuring out.

But we have 144 standardized workflows that work.

We have an architecture that separates concerns properly.

We have test coverage that actually means something.

We have a deployment process that works.

We have beta testers using this in production to manage their own agency and clients.

Most importantly, we have a framework for thinking about AI infrastructure that isn’t just “write better prompts.”

Because the companies that win the AI race won’t be the ones with access to the best models.

They’ll be the ones who built the best systems around those models.

The ones who figured out the abstraction layer.

The ones who built the operating system while everyone else was still writing assembly code.

That’s what we’re doing.

And if you’re building AI tools and you’re not thinking about infrastructure.

You’re already behind.

It’s 4am and I just gave an AI cat named Claws the ability to watch everything I do.

Not in some creepy surveillance way.

In a “I literally cannot remember what I was working on 3 hours ago” way.

ScreenPipe captures my screen continuously - every tab, every terminal command, every half-written message.

Every 5 minutes, GPT-OSS-20b summarizes what I did and dumps it into my Obsidian vault with auto-generated tags and wikilinks.

Then my AI assistant syncs those logs to its own memory.

So when I ask “what have I done today?” it actually knows.

Not because I told it.

Because it watched.

This is either the future of knowledge work or the first chapter of a Black Mirror episode.

Probably both.

The Problem I Couldn’t Solve

I lose hours to forgetting what I was doing.

You know the feeling.

You’re deep in something - a design mockup, a code refactor, a half-finished article.

You switch to Slack for one second.

Then email.

Then Twitter.

Thirty minutes vanish.

You return to your original tab and stare at it like it’s written in another language.

What was I doing here?

Why did I open this?

What problem was I trying to solve?

The problem isn’t discipline.

I do time-block and shut off communication time.

I’ve talked about Maker Days vs Manager Days.

But sometimes theres urgent issues that demand your attention.

You genuinely do have to respond to that Slack message.

And your brain loses context on what you were working on.

Even a miniscule interruption can mess you up for the next 30 minutes.

I’ve been using AI assistants for years.

Claude, ChatGPT, custom agents.

They’re incredible until you realize they have the same problem as most humans - they have the memory of a goldfish.

Every conversation starts from zero.

“Here’s my project again. Here’s what I’m trying to do again. Here’s the context you need again.”

It’s like hiring a brilliant consultant who shows up every morning with amnesia.

There’s ways around this (mem0 is pretty good) but it’s usually still not super accurate.

So I started keeping a daily work log in Obsidian.

Every hour I’d review my Work Log journal and condense it into a quick Obsidian note about what I did.

But sometimes I’d be in a flow state and I’d forget to do it.

Or I’d batch it at the end of the day and misremember half of it.

My log was less “accurate record” and more “creative fiction based on vague vibes.”

Then I found ScreenPipe.

The Setup That Changed Everything

ScreenPipe is open-source software that does one thing: it records everything on your screen, continuously, locally, forever.

Every pixel.

Every window.

Every keystroke.

It captures raw screen frames and processes them using OCR to extract text, then indexes everything into a searchable database.

All of it lives on your machine.

Nothing goes to the cloud.

It’s like having a DVR for your entire digital life.

I installed it on a Friday night.

It should have been an easy install with a nice Mac app and everything, they advertised that on their site.

But it turns out the devs basically ditched the project for a different cash grab, stopped supporting it entirely, and some supporters who paid $400 were left high and dry.

Luckily thought, it’s open source meaning the code is sitting right there on Github.

Copy URL > paste to Claude Code > ScreenPipe is working within about 10 minutes.

It runs silently in the background, eating maybe 5% CPU.

Within an hour it had captured more context about my work than I could manually document in a week.

But raw screen recordings aren’t useful.

I needed structure.

Context.

Meaning.

That’s where the AI comes in.

I wrote a script that pulls screen captures from ScreenPipe every 5 minutes.

It sends those frames to GPT-OSS-20b.

This is OpenAI’s open source model.

It’s really good and usage via OpenRouter is very cheap.

Processing a whole month of me working daily will cost about $1

I gave it a prompt with some context about me and my work.

Minutes later I get an update.

Then that note was automatically saved to my Obsidian vault.

Timestamped.

Tagged.

Linked.

This happens every 5 minutes.

All day.

Within a week I’ll have a complete AI-generated journal of everything I’ve done.

Every project I touched.

Every problem I solved.

Every rabbit hole I went down.

But I wanted to go further.

Giving the AI Eyes

Claws is my customized version of Clawdbot - an open-source, self-hosted AI assistant that runs on a DigitalOcean droplet that costs about $5 /month.

Unlike ChatGPT or standard Claude, Clawdbot lives on your own infrastructure.

It connects to whatever messaging apps you actually use.

WhatsApp, Telegram, Discord, Slack.

It has persistent memory.

It can run custom “skills” - reusable workflows with guardrails.

And it’s hackable.

You can build whatever capabilities you need directly into it.

I named mine Claws because I name things stupidly and I like cats.

Look he even sends me little cat emojis.

Claws helps me write, debug code, research topics, plan projects.

The works.

But it had no persistence beyond what I manually told it.

Every conversation was isolated.

I’d tell it about a project on Monday and have to re-explain everything on Tuesday.

So I connected my ScreenPipe logs to Claws’ memory system.

Now, every time Claude generates a work log from my screen, it gets synced to Claws’ vector store knowledge base.

Claws can see my entire work history.

Not because I manually updated it.

Because it has access to the same logs Claude generated by watching my screen.

The first time I asked Claws “what was I working on earlier today at 3pm?” and it answered correctly, I got chills.

“You were debugging the authentication flow in the user dashboard. You found a token refresh bug causing logout loops and pushed a fix to staging.”

Perfect recall.

Zero effort.

I started asking weirder questions.

“What projects have I spent the most time on today?”

“When did I last work on the email automation feature?”

“What was I doing right before I got distracted and spent an hour on Twitter?”

It knew.

All of it.

Claws became less like a tool and more like a second brain with better memory than my first one.

What Perfect Recall Actually Looks Like

Within one day, my Obsidian vault has over 1,000 auto-generated notes.

My screen recordings total about 4GB of MP4 files.

I can search my entire work life.

“Show me every time I worked on the API refactor.”

Instant results.

“What did that Twitter thread about biohacking say?”

There it is.

It’s solved problems I didn’t even know I had.

I used to lose hours redoing work I’d already done because I forgot I’d done it.

Now I search my logs first.

“Did I already try this approach?”

Yes.

Three days ago.

It didn’t work.

Here’s why.

I used to struggle to write weekly updates for my team.

Now I just ask Claws to summarize my week.

It generates a full report in 30 seconds.

I used to wonder where my time went.

Now I know exactly where it goes.

Turns out I spend about 90 minutes a day in Slack.

Another 60 minutes reading articles I’ll never finish.

And like 7 hours fighting with Claude Code as I make cool shit.

Seeing your actual behavior reflected back at you is uncomfortable.

You can’t lie to yourself anymore.

But it’s also liberating.

This will let me optimize differently.

I can examine my writing habits and figure out the optimal time to block off any meetings so I can focus.

I’ll notice if I get sucked into Twitter whenever I’m stuck on a hard problem, so I’ll block it during work hours.

I’ll see that I work on my most important projects in random 20-minute bursts instead of focused blocks, so I’ll restructure my week around that reality instead of fighting it.

Perfect recall won’t just help you remember.

It’ll help you see patterns you’re blind to.

The Part That Feels Wrong

There’s something deeply weird about this.

Every moment of my work life is being recorded, processed, analyzed, and stored.

An AI is watching me constantly.

It knows what I’m working on before I do.

It remembers conversations I’ve forgotten.

It can replay moments I wish I could forget.

I’m not being surveilled by some company.

I’m surveilling myself.

And I gave an AI assistant access to the surveillance.

Sometimes I catch myself wondering if I should be doing this.

Then I remember I already live in a world where Google indexes my emails, Slack logs my messages, my phone tracks my location, and browser extensions monitor every site I visit.

At least this surveillance works for me.

But it’s still strange.

I’ve created a machine that knows me better than I know myself.

It has perfect memory.

I don’t.

It sees patterns I miss.

It never forgets context.

In a weird way, Claws is becoming the more reliable version of me.

There are practical concerns too.

Those MP4 files add up fast.

At my current rate I’m going to have to buy a home NAS setup just to store my log videos.

That’s manageable now but it won’t scale forever.

I’ll probably need to add a retention policy.

Delete anything older than 3 months.

Or compress aggressively.

Or move to cheaper storage.

There’s also the question of what happens if someone gets access to my machine.

My entire digital life is sitting there in a database.

Every password I’ve typed.

Every private message.

Every dumb thing I’ve googled at 2am.

ScreenPipe doesn’t send anything to the cloud, but that also means I’m responsible for securing it.

And then there’s the bigger question.

What happens when this becomes normal?

When everyone has perfect recall of everything they’ve ever done?

When you can ask an AI to replay any moment from your past work life?

Does that make us more productive?

Or does it just create a new kind of anxiety?

Why This Matters More Than You Think

This isn’t just about me fixing my memory.

We’re entering an era where AI agents need context to be useful.

The biggest limitation of current AI assistants isn’t intelligence.

It’s amnesia.

They’re brilliant for 10 minutes and then they forget everything.

Giving AI persistent memory changes what’s possible.

Imagine an AI that’s worked with you for a year.

It knows your projects.

Your preferences.

Your patterns.

It remembers that meeting from six months ago where you decided to pivot the product strategy.

It recalls the bug you spent three days debugging and knows not to suggest that approach again.

That’s not a tool anymore.

That’s a colleague.

The technology already exists.

ScreenPipe is open-source.

Claude can process images and generate structured notes.

Obsidian can store and link everything.

Clawdbot gives you a self-hosted AI assistant you can customize completely.

You can build this entire system in a weekend.

What’s missing is the cultural shift.

Right now most people are uncomfortable with the idea of recording everything they do.

It feels invasive.

Creepy.

Orwellian.

But I think that changes fast.

The same way we went from “I would never put my real name on the internet” to “here’s a live stream of my entire day” in about fifteen years.

The same way we went from “I don’t want my phone tracking my location” to “why isn’t my food delivery app showing me real-time updates?”

We trade privacy for convenience every single day.

And this is incredibly convenient.

Once people experience what it’s like to never forget anything, never lose context, never have to rebuild their mental model from scratch - they won’t want to go back.

I know I won’t.

What I’d Do Differently

• Start with retention policies from day one. Decide how long you actually need to keep screen recordings. I’m currently keeping everything forever which is dumb. Most of it has no long-term value. I should probably auto-delete anything older than 90 days except for specifically tagged sessions.

• Encrypt your database. ScreenPipe stores everything in plaintext by default. That’s fine if you’re the only person who ever touches your machine. It’s a disaster if your laptop gets stolen or someone gets remote access. I added encryption using a simple wrapper script. Took an hour. Worth it.

• Be thoughtful about what gets logged. I quickly realized I don’t want my AI seeing my personal email, my banking, or my therapy appointments. I added filters to exclude certain apps and domains. My work logs are for work. Everything else stays private.

• Don’t try to summarize everything in real-time. My first version tried to process every screen change immediately. It was slow and expensive and generated way too many useless notes. Every 5 minutes is the sweet spot. Frequent enough to maintain context. Infrequent enough to be meaningful.

• Invest time in your prompts. The quality of your AI-generated logs depends entirely on how you ask the AI to summarize your work. My early summaries were garbage. “User was looking at a screen with text.” Cool. Very helpful.

Now my prompts are specific. “Identify what the user was working on, what problem they were solving, what progress they made, and what questions remain. Format as a structured note with title, tags, and wikilinks to related concepts.”

The Future I’m Already Living

I just installed this today.

But I already see where this is going.

No more spending the first 20 minutes of every work session trying to remember what I was doing.

I’ll just ask Claws.

It’ll tell me exactly where I left off, what problems I was stuck on, and what I should work on next.

No more losing entire threads of thought.

I’ll trace them back through my logs.

I’ll see the moment I had an idea, watch how it evolved over days, and understand why I abandoned it or pursued it.

No more feeling like I’m constantly starting over.

I’ll be building on top of everything I’ve already done.

This is what augmented cognition actually looks like.

Not brain implants or neural interfaces.

Just a script, an AI, and the willingness to record everything.

It’s terrifying because it’ll reveal how little I actually remember on my own.

It’s beautiful because I won’t have to anymore.

And honestly?

I think this is just the beginning.

We’re maybe two years away from AI agents that can watch you work, learn your patterns, and start doing tasks autonomously.

They’ll know which emails you actually care about because they watched you ignore the others.

They’ll know how you like code formatted because they watched you refactor it.

They’ll know when you’re stuck because they’ve seen you stuck before.

Right now I have to explicitly ask Claws for help.

Soon it’ll just offer help at the exact moment I need it.

“I noticed you’ve been stuck on this bug for 45 minutes. You solved something similar last month. Want me to pull up those notes?”

That’s not science fiction.

That’s just connecting the pieces that already exist.

I gave an AI my entire screen.

Soon I’ll give it my entire workflow.

Then my entire job.

Not because I want to be replaced.

Because I want to be augmented.

And if that’s what the future looks like, I’m ready for it.

Even if it’s a little bit terrifying.