Anthropic Says Engineers Won’t Exist in a Year. It’s Also Paying Them $570K Today.

The most honest job posting in tech history might also be the most revealing thing about where the industry actually stands.

A job listing recently made the rounds that deserves more attention than it got.

Anthropic the company whose CEO publicly stated AI will replace software engineers within 6–12 months posted a Software Engineer role at $570,000 total compensation. Base $300K. Equity $220K. Signing $50K.

Ai Generated Image

Buried at the bottom of the offer letter, in a red-circled note that the internet couldn’t stop screenshotting:

“Note: This role may not exist in 12 months.”

Take a moment with that.

A company confident enough in AI’s trajectory to say so publicly. Not confident enough to stop hiring engineers at half a million dollars a year.

That tension isn’t hypocrisy. It’s actually the clearest signal about where the market really stands.

What the Hiring Data Is Telling You

Strip away the headlines and look at what’s actually happening at the infrastructure layer of AI companies:

What CEOs Say Publicly:
  "AI will replace software engineers"
  "We're building toward autonomous coding agents"
  "This role may not exist in 12 months"
          |
          v
What Companies Are Actually Doing:
  Hiring L5/L6 engineers at $500K+
  Growing infrastructure teams
  Competing aggressively for senior talent
          |
          v
Conclusion:
  The rhetoric and the resource allocation
  are pointing in opposite directions

This isn’t unique to Anthropic. Across the industry, the companies building AI the hardest are also the ones paying engineers the most. That’s not a coincidence it’s a data point.

The Two-Track Collapse (and What’s Actually Collapsing)

There is a real story about job displacement. It’s just more specific than the headlines suggest.

Engineering Role Spectrum:

[Task Executor] ──────────────► [Problem Solver]
        |                                |
  Writes boilerplate               Architects systems
  Follows specs                    Makes trade-offs
  Manual QA passes                 Debugs complex failures
  Repetitive reporting             Decides what to build
        |                                |
        v                                v
  HIGH DISPLACEMENT RISK          LOW DISPLACEMENT RISK
  (shrinking, not gone)           (still hiring, still paid)

The roles getting squeezed are real and worth naming:

• Junior positions built around generating routine code
• QA roles that were purely manual, click-through testing
• Entry-level analyst work that was mostly formatting data and producing fixed reports

These aren’t gone. But there are fewer openings, the bar has moved, and the volume of those roles is contracting.

Senior engineers people who can design a system from ambiguous requirements, make build-vs-buy decisions, navigate organizational constraints, and actually ship something that works in production remain in short supply and high demand.

Why “Replacing Engineers” Is the Wrong Frame

Here’s what an AI-assisted engineering workflow actually looks like today:

┌──────────────────────────────────────────────┐
│              Feature Development Loop        │
│                                              │
│  Engineer defines requirements               │
│         │                                    │
│         ▼                                    │
│  AI generates boilerplate / scaffolding      │
│         │                                    │
│         ▼                                    │
│  Engineer reviews, critiques, refactors      │
│         │                                    │
│         ▼                                    │
│  AI suggests tests, catches edge cases       │
│         │                                    │
│         ▼                                    │
│  Engineer makes architecture decisions       │
│  (what AI cannot do: weigh business          │
│   context, technical debt, team capacity)    │
│         │                                    │
│         ▼                                    │
│         Ship                                 │
└──────────────────────────────────────────────┘

Notice what’s missing from the AI steps: judgment. Context. Trade-offs. The hard part.

# AI is very good at this:
def generate_crud_endpoints(model: str) -> List[Route]:
    # Generates standard REST endpoints in seconds
    ...

# AI still needs human direction for this:
def decide_architecture():
    """
    Should we:
    - Build a microservice (scalable, complex ops)
    - Extend the monolith (fast, growing debt)
    - Use a managed service (cost, vendor lock-in)

    Answer depends on: team size, runway, growth projections,
    existing infra, org priorities.

    No model has that context. You do.
    """

The job isn’t disappearing. The easy part of the job is disappearing. And the easy part was always the part that made the job feel like task execution rather than engineering.

The Bar Has Moved. That’s Different From the Door Closing.

There’s a version of this story that’s worth taking seriously not as panic, but as calibration.

If the daily job is converting tickets into code that follows an established pattern, that workflow is genuinely more automatable than it was two years ago. That’s real.

But the people who are designing the systems those tickets get filed against, making decisions about what to build and what not to build, debugging failures that don’t have Stack Overflow threads — they’re not only surviving, they’re increasingly valuable. Because as AI handles more execution, the premium shifts entirely to judgment.

Value Distribution in Engineering (Shifting):

2022:  [Judgment 40%] ──── [Execution 60%]

2025:  [Judgment 70%] ──────────── [Execution 30%]
                ▲
                │
         This is where
         compensation is
         concentrating

Read the Behavior, Not the Press Release

The most useful thing a software engineer can do right now isn’t read AI doomsday threads. It’s watch what companies with real money on the line are actually doing with that money.

They’re hiring. Selectively. At high salaries. For people who solve problems rather than execute tasks.

The Anthropic job posting, fine print included, is more honest about the industry’s real position than most commentary. They don’t know exactly how this plays out. Nobody does. But they need engineers today senior ones and they’re competing hard to get them.

That’s not contradiction. That’s the market telling you something.

The question isn’t whether AI changes engineering. It already has. The question is whether you’re positioned on the judgment side of the bar or the execution side.