The Operating Layer

Everyone is still talking about models.

The bigger story is the operating layer around the models.

Give two people the same frontier model and you get two completely different outcomes. One gets a toy. The other gets leverage.

That gap has much less to do with raw model intelligence now. It comes from everything around the model: coding agents like Codex, Claude Code, and Cursor; durable context; transcripts; dictation; skills; subagents; plan mode; routing; evaluation; and whether the system can actually touch the work.

That is where I spend most of my time now.

I have been saying this since January: if you are not using a coding agent by now, you are late.

I do not mean late in the engineer-only sense. I mean late in the broader knowledge-work sense. Coding agents are general productivity tools now. The label is already too small for the job.

Most people are still at the surface layer. They open a chat, ask for help, maybe save a prompt somewhere, and call that a system.

That worked for a while.

It already feels old.

I introduced a five-level AI competency spectrum to my team in February. It still feels right. If anything, level five has already split into a few sub-levels.

The useful frame is simpler: what level of the stack are you operating at?

Most people are still at level one.

The five levels

Level 1: basic Q&A

This is where most people still live.

They get better at prompting. They ask for summaries, drafts, ideas, spreadsheet formulas, maybe some code.

That is fine. It is also table stakes now.

If your whole workflow fits inside a single chat box, you are still using the category like a consumer app.

Level 2: daily work integration

This is the first real unlock.

The model needs to be attached to your actual workflow. Your real notes. Your real documents. Your real meetings. Your real rough thinking.

I dictate much more than I type now. Roughly half the time. Being able to yap into a mic gets more context out of me with less self-editing. The model sees how I actually think instead of the cleaned-up version I type after pruning half the idea tree. Codex dictation is usually enough for me now. Before that I leaned harder on Wispr Flow.

I also transcribe basically every meeting. Granola is still my default. That changed how I think about meetings. I used to see them as a tax. Now they are usually neutral because the transcript becomes reusable raw material for writing, planning, follow-ups, and content.

For the same reason, I care a lot about tools like Familiar that turn more of the real work into context the agent can actually use.

This is where a lot of people stall. They keep obsessing over output quality while starving the system of context.

Level 3: custom AI projects and skills

Once the model has context, repeated work needs to become a reusable workflow.

This is where skills matter. If you want a public reference for this pattern, Anthropic’s skill-creator is still useful.

If I do something more than a few times, I do not want to keep re-prompting it. I want it packaged. Research. Writing. Extraction. Planning. Brief creation. Review. Handoffs. Weekly ingest. Whatever it is.

Prompts are fine. Packaged intent is better.

This is also where most people misunderstand AGENTS.md. It should mostly be a pointer layer into skills, references, and durable context. If you are dumping your whole operating system into one giant instruction file, the system is already getting worse.

Level 4: building applications and workflows

This is where the role starts to change.

At level four, you stop acting like a power user and start acting like a builder. You use coding agents to prototype, analyze, write docs, shape plans, build internal tools, and wire whole workflows together.

This is also where the old role boundaries start to break down. Product, design, and engineering are all moving toward a broader builder surface.

This is also where harness quality starts to matter more than model debates. Same model, different harness, radically different result. Better routing, better tool surfaces, cleaner plan files, smaller worker models on bounded subtasks, stronger evaluation. That is the product.

It is why I keep telling PMs to use coding agents. The builder surface has widened. If you still think code generation is only for engineers, you are reading the shift too narrowly.

Level 5: personal AI agents

This is where it turns into an operating system.

The model is no longer helping you inside a chat. It is working across a persistent environment with memory, files, workflows, tools, and recurring jobs.

This is the level I care about most now.

For repeatable work, my bias is simple: UI usage should keep trending toward zero.

I store as much as I can in markdown and keep pushing everything into a knowledge graph. Meeting transcripts. Notes. Documents. Calls. Emails. Messages. Bookmarks. Reading history. Session logs. Screen captures. Health data. I ingest everything I reasonably can.

If you want public starting points for that, Karpathy’s LLM Wiki is still the cleanest reference and gbrain is a good more built-out version.

That sounds excessive until you use an agent that can actually work across your world instead of inside one app.

Today Codex is increasingly my default surface because the pieces fit together well: durable threads, terminal access, browser use, computer use, dictation, automations, and mobile access. A pinned chief of staff thread is one of the best patterns I have found. It owns routing. It remembers standing context. It coordinates other threads. It cuts down the restart cost. Jason Liu has written publicly about a similar pattern.

I still run OpenClaw and Hermes on a Mac mini too. They feel different. Codex feels like an extension of me. OpenClaw feels more like onboarding an AI employee. Both modes matter. They are good at different jobs.

Below the waterline

Most AI discussion still happens above the waterline. People compare model personalities, benchmark deltas, and chat UX.

The compounding value is below the waterline.

It comes from data access, durable files, dictation, meeting transcripts, skill libraries, planning loops, subagent routing, evaluation, permissions, cheap worker models for mechanical work, stronger models for judgment and synthesis, and clean handoffs between them.

Most AI disappointment is upstream. The problem statement was weak. The context was weak. The tool surface was weak. The evaluation criteria were weak. Then people blame the model.

I keep coming back to the same question: how much of yourself have you fired, and how many AI employees have you hired?

That question lands differently once you move past level one. You stop asking “how do I do this task?” and start asking “how do I train the system to eliminate this class of task?”

Human work gets narrower

I have a pretty simple mental model for what stays human.

Agents are good at almost everything except work that is both new and hard.

That is where I want human attention.

Novel strategy questions. Real judgment. Ambiguous trade-offs. Product taste. Second- and third-order effects. Understanding what matters and why.

This matters because a lot of people swing too far in one of two directions.

One group treats AI like autocomplete and gets tiny gains.

The other group delegates their thinking and accepts whatever comes back.

Both are weak positions.

The whole job in product, strategy, and leadership is still thinking. The hard part is deciding what problem is actually worth solving, what trade-offs you are making, and what happens after the first-order win. You can automate a huge amount around that. You cannot delegate understanding.

The company angle

The spread inside teams is huge now.

On the same team, you can have one person using AI as a better search box and another person running a small operating system with crons, skills, context files, and reusable workflows. That is not a minor skill gap. That is a completely different level of leverage.

A new hire using AI well can run circles around someone with five years of company context who refuses to adapt. I already believe that.

AI adoption inside a company quickly turns into an internal developer experience problem.

The companies furthest along are investing in shared skills, shared conventions, shared data access, shared evaluation, safe permissioning, clean tool surfaces, and actual training on how to work this way.

In other words: internal infrastructure.

That is where the real moat starts to form. The model vendors will keep leapfrogging each other. Your context, workflows, and operating layer can compound.

I also think people should stay harness-agnostic. I use Codex heavily right now. I still use Claude Code, Cursor, and other harnesses. The wrapper market is moving too fast to get religious about one surface. Keep the system portable: markdown by default, inspectable tools where you can get them, and CLIs when they do the job cleanly.

What I would do right now

If you want to get serious about this, I would do five things.

1. Start using a coding agent every day. Claude Code, Codex, or Cursor. Pick one and get reps.
2. Capture more raw context. Dictate more. Transcribe meetings. Stop forcing the model to work from the cleaned-up version of your thinking.
3. Give the agent access to your real world. Notes, docs, transcripts, code, bookmarks, messages, whatever you can route cleanly. Tools like Granola and Familiar help because they capture more of the actual work.
4. Turn repeated workflows into skills and start non-trivial work in plan mode. Anthropic’s skill-creator is a decent public place to start.
5. Keep the system inspectable and portable. Markdown, files, simple tools, clear routing.

If you do that, you are already ahead of most people.

The laggard line has moved.

The bigger opportunity is building an operating system around the models that gets better every week.