Are you to be replaced with AGENT.md and few SKILL.md?

The Matrix, Part 2: Are You About to Be Replaced by an AGENT.md and a Few SKILLS.md Files?

I've been thinking about this a lot lately. Not in the doomer, hand-wringing way. In the practical, "I'm watching this happen in real time" way.

The setup is straightforward: Claude Code with a well-defined AGENT.md and a handful of SKILLS.md files, wired into a Git workflow. That's it. That's the stack. And my ambitious — but increasingly confident — take is this:

It can replace a mid-tier developer.

The Convergence Is Already Here

Look at what's shipping right now. Perplexity Computer, OpenClaw, Anthropic's Cowork, Kimi K2.5, OpenAI Frontier. These aren't research demos anymore. They're products. They're agents that can reason, plan, execute multi-step tasks, and self-correct.

The pattern emerging across all of them is the same: give the agent a persona, give it skills, give it context, and point it at a codebase. It figures out the rest.

What AGENT.md + SKILLS.md Actually Gets You

Think of AGENT.md as the developer's identity — their role, their decision-making framework, their constraints. "You are a frontend engineer working in a Next.js monorepo. You write tests before implementation. You never push directly to main."

SKILLS.md files are modular capabilities. One for writing React components. One for database migrations. One for PR descriptions. One for debugging CI failures. Stack them like building blocks.

This isn't prompt engineering theater. This is configuration as competence. You're not hoping the model does the right thing — you're defining what the right thing is, in a format the agent can internalize and execute against.

The Mid-Tier Developer Problem

Let me be specific about what I mean by "mid-tier." I'm talking about the developer who:

• Can take a well-scoped Jira ticket and implement it
• Follows established patterns in a codebase
• Writes decent but not exceptional code
• Needs occasional guidance on architecture decisions
• Produces work that passes code review with minor comments

That developer's workflow is almost entirely pattern-matching and execution. And that's exactly what these agents are terrifyingly good at.

Claude Code, pointed at a repo with good AGENT.md and SKILLS.md files, can already:

• Read a ticket description
• Explore the codebase for relevant patterns
• Implement a feature following those patterns
• Write tests
• Open a PR with a coherent description
• Respond to review comments

Is it perfect? No. Does it need supervision? Yes. But so does a mid-tier developer.

What It Can't Do (Yet)

I'm not delusional about this. The agent falls apart when:

• The problem is genuinely ambiguous and requires product intuition
• Cross-system architecture decisions need to be made
• You're in uncharted territory with no existing patterns to follow
• Debugging requires understanding the why behind a system, not just the what
• Stakeholder communication and negotiation are involved

These are senior+ engineer things. These are the things that make experienced developers valuable. And they're not going away anytime soon.

The Uncomfortable Math

Here's where it gets real. A mid-tier developer costs $120-180K/year fully loaded. Claude Code with a well-configured agent setup costs... what, a few hundred dollars a month in API calls? Maybe a thousand if you're running it hard?

Even if you need a senior engineer spending 20% of their time reviewing and steering the agent's output, the economics are brutal. One senior engineer plus three or four agent workflows could plausibly replace a team of five or six.

I don't love writing that. But I'd rather say it plainly than pretend it isn't happening.

What This Means for You

If you're a mid-tier developer reading this, the move isn't panic. The move is velocity. Learn to work with these tools. Become the person who configures the agents, reviews their output, and handles the problems they can't solve. Move up the abstraction ladder.

If you're a senior engineer or engineering lead, start experimenting now. Build your AGENT.md files. Define your SKILLS.md library. Figure out where agents slot into your team's workflow before someone above you figures it out for you.

If you're a founder or CTO, you're probably already doing this. And if you're not, your competitors are.

The Matrix Analogy Holds

In Part 1, I talked about how AI is reshaping the reality of what it means to write software. Part 2 is the sequel nobody wanted: the machines aren't just tools anymore. They're teammates. And they're getting promoted fast.

The question isn't whether agent-driven development works. I've seen it work. The question is how quickly organizations will restructure around it — and what happens to the people who don't adapt.

If your entire job can be described in a markdown file, what does that say about the job — or about how powerful markdown files have become?