How a One-Person Company Builds an AI-Native Workflow: 5 Tips

Over the past while, I’ve moved my entire Affiliate media buying operation onto an AI-native workflow.

The result: the time I spend watching ads each day went from 4 hours down to 1. The rest of the time I spend thinking about what the next project should be.

How to build this workflow: today I’m sharing 5 tips.

1. Tools determine the output

There are just two mainstream options: Codex and Claude Code.

I suggest picking one. If you don’t want to fuss with accounts and want stability, Codex first. If you can handle it, Claude Code is good too. Personally I prefer Claude Code.

Among the tools I currently work with, there are 5 core ones:

Obsidian Vault: the second brain. Every decision, post-mortem, profile, campaign record and piece of intel settles in there.

Codex: handles scripts and coding tasks with high stability requirements.

Claude Code: writes new Agents and builds experimental Flows.

Cowork: handles file-type work. My earlier post “Claude Cowork: My First Digital Employee Does My Hong Kong Company’s Books” covered how it helps me reconcile accounts.

OpenClaw/Hermas: scrapes ad intel + competitor analysis; the intel syncs to Obsidian, then flows back into the Adv Agent.

More tools isn’t better. The key is whether they can link up.

For example: competitor ads Hermas scrapes → synced to Obsidian → Obsidian in turn linked to the Adv Agent.

That way, when I make decisions, the data sources aren’t just my own campaigns; they include competitors’ latest moves.

2. Skills define your Flow

Writing Skills with a large model is easy now, but whether a Skill is actually useful to the business comes down to one standard: Re-flow.

Re-flow means: taking an action that used to be done by hand and sinking it into a reusable process.

For example: when I gave OpenClaw $100 to run ads earlier, some people felt it was faster to click a couple of times themselves, and that the AI makes mistakes easily.

Look at it another way: it was validating the process for me. Once that process runs through, none of my later operations of the same kind need manual intervention.

It’s like stepping out and letting a validated Flow execute for me. That’s a completely different thing from creating ads by hand over and over.

Whether a Skill has really merged into the process is simple to judge: without the AI, the process can’t run.

If without the AI it’s only a bit slower, then the AI is still just an accelerator; it hasn’t really taken over that step.

A Skill that’s really merged into the process changes the structure, not the speed.

3. Replace discipline with environment

I’ve brought a few friends into the industry before, and none of them stuck with it.

Over the years my view on relying on self-discipline has changed. People are kindest to themselves and the quickest to make exceptions.

“That’s enough testing for today”, “I’ll just work it out by hand”: the moment thoughts like these appear, the whole system becomes hard to build.

My solution is to have scripts and protocols force it for me.

Two concrete examples.

Example one: at the start of my Claude Code sessions there’s a protocol that automatically runs an audit script telling me how many articles have been published but haven’t had diff learning done.

I don’t have to think about it; the script tells me, so it never drops.

Example two: when I finish an article and give the AI the link, it automatically runs the whole chain: fetch the published version → diff it against the draft → extract the sentences I changed and why → write it into Obsidian.

The whole process doesn’t need me to trigger it.

4. Before the AI works, define what counts as good

Before you do anything with AI, answer one question first: what’s the standard for good?

My own example: before creating a campaign now, it must first read three Vault pages: ad preferences, historical data, intel collection. Drafting a campaign without reading those = a violation.

Why? AI knows a lot, but it doesn’t know who I am, which GEOs and verticals I’m good at, or which of my past campaigns won.

So I had the AI do one thing: reverse-distill my campaign data.

Reverse distillation means: from all my historical winners and losers, work backwards to extract my preferences and the patterns in how I play.

If you just have the AI analyze the winning campaigns directly, it lists a pile of unrelated features.

So I first defined for it what counts as a shared pattern: it must be traceable to a specific campaign, it must have a specific citation, and it must distinguish unique features from shared rules.

Define what good is first, then let the AI work. Skip this step and every AI output after it is worthless.

5. A 5-layer structure + judgment is the scarce resource

My whole current structure has 5 layers:

Layer 1, the data layer: Obsidian Vault.

10 years of decisions, campaign records, reader profiles and failure post-mortems settle in there. When the AI works with me it can read the complete context, instead of starting from zero every time.

Layer 2, the tool layer:

Claude Code writes code, Cowork handles files, Hermas scrapes intel. Each tool has a clear role with no overlap.

Layer 3, the process layer:

The Adv ad automation system + the Obsidian knowledge base run in the background. Monitoring, creation and optimization run automatically; I make the key decisions.

Layer 4, the Skill layer:

The CLAUDE.md protocol defines every workflow: how to ingest content, how to write articles, how to lint, how to do diff learning.

Layer 5, the judgment layer:

Deciding what the AI does, what I do, and the boundaries the AI is never allowed to cross.

However well the first 4 layers are built, if layer 5 is wrong, the whole system is junk.

And why is the judgment layer the scarce resource? Because it can’t be outsourced, and it can’t be distilled.

I’m running 3 projects at the same time right now: Constructor Page arbitrage, building the Adv Agent, and linking up the Obsidian knowledge base.

They look unrelated, but when I link them together, it’s 10x leverage.

That ability to link them up is what judgment looks like in practice. It comes from three things:

Experience: what I’ve run myself, the pits I’ve fallen into. The ad targeting I spent tens of thousands of dollars testing can run stably for 1-2 months. AI can’t replace that; it never lost that money for me.

Data: real industry data. Besides distilling yourself, you also distill others, to build your own coordinate system for judgment. AI can aggregate, but the final call is still mine.

Thinking time: uninterrupted, continuous thinking. In the past, 3-4 hours a day went to watching accounts, sorting reports and reconciling. Now automation has given that time back to me, and thinking time has gone from 1 hour a day to 3.

In closing

This architecture has freed up a lot of time for me, so besides running ads I can do a few other things.

If I had to pick my favorite feature, I’d pick self-learning.

Self-learning means: once the data layer, tool layer, process layer and Skill layer all form closed loops, the system optimizes itself.

1. Campaign data flows back into Obsidian

2. New patterns in Obsidian automatically update the Adv Agent’s decision logic

3. Competitor moves scraped by Hermas become new test tasks

4. Test results flow back into the data layer

Even if I don’t push it, it keeps rolling forward on its own.

That’s the real endpoint of AI-native: not AI doing the work for me, but this workflow growing for me.