Cursor shipped something this week that most engineering managers haven't fully processed yet.
They called it "Automations." What it actually is: a system that lets an AI coding agent take action without waiting for a human to ask. Slack message comes in. Codebase event fires. Incident alert triggers. The agent reads it, opens the relevant files, and starts working.
You didn't type a prompt. You didn't give it a task. The task found the agent.
That's not an IDE update. That's a new kind of team member.
What Just Changed
The way we've thought about AI coding tools for the past two years: developer has a problem, developer describes the problem, AI proposes a solution, developer evaluates and accepts or rejects. Human in the loop at every step. AI as accelerant.
Cursor Automations breaks that model. The agent is now watching for conditions. When the conditions are met, it acts. The developer's role shifts from "person who initiates" to "person who reviews."
That sounds subtle. It isn't.
When you have a team member who works on their own initiative — who sees the Slack message about the bug before you do, and already has a proposed fix by the time you read it — your job as an engineering manager changes. You're not managing capacity and task assignment anymore. You're managing judgment and review.
Most engineering teams are not set up to manage judgment and review. They're set up to manage capacity and velocity. Those are different things.
The Productivity Measurement Problem
If an agent opens a PR before your developer does, who gets credit? If an agent catches a performance regression at 2 AM, does that count toward your sprint velocity? How do you evaluate engineer performance when the agent is doing a meaningful fraction of the initiating work?
These are not hypothetical questions. They're operational problems that engineering managers are going to face this quarter.
The companies that get ahead of this will define new measurement frameworks now — before their team culture calcifies around metrics that no longer reflect how work actually happens. Cycle time, PR review quality, agent calibration, system reliability: these are the engineering metrics for 2026. "Story points completed" was already showing its age. It's now officially dead.
What You Actually Need to Hire For
A team with an autonomous coding agent doesn't need fewer engineers. It needs different engineers.
You need people who can:
- Define the scope of what the agent should and shouldn't touch
- Write clear enough requirements that an agent can act on them without ambiguity
- Review agent output with the same rigor they'd apply to a senior developer's PR
- Recognize when the agent is confidently wrong — which is harder than recognizing when it's obviously wrong
The last one is the skill that matters most. Agents trained on your codebase will do plausible-looking work in areas where they shouldn't be working. The human job is knowing where the guardrails need to be.
That's a senior engineering judgment skill. It's not taught in bootcamps. It's not signaled by years of experience. It's a specific combination of domain knowledge and AI systems literacy that barely exists as a hireable profile yet.
The companies that build recruiting pipelines for this profile now — before the rest of the market catches on — will have a structural advantage for the next 36 months. The companies waiting for it to show up on job boards are going to be managing teams in 2027 where the agents are more capable than the reviewers. That's when things get expensive.
VC5 Consulting helps technology leaders find engineers who can work alongside autonomous AI systems — not just use AI tools. If you're thinking about what your team needs to look like in the next two years, let's talk.