AI and the Staff Engineer: How to Multiply Team Leverage When Everyone Has the Same Tools
AI has made individual coding tasks faster, but it has not made staff engineering less important. It has moved the leverage point: from personally writing more code to teaching teams and systems to make good decisions repeatedly. At QCon San Francisco 2026, Pinterest’s Jordan Cutler showed how that shift can turn one engineer’s judgment into shared team capacity.
Key Takeaways- AI tools can raise output, but the gains may differ widely across engineers.
- Staff engineers can multiply their impact by improving their own practice, sharing team judgment, and changing repeatable systems.
- Small, safe automation beats waiting for a perfect platform.
- A 10x engineer is not simply a faster coder; the larger goal is helping many people work better.
I’m Ermenildo Castro, a Filipino author in Seattle who has worked in software engineering at Google, Microsoft, Amazon, and Zulily. I have seen tools change how quickly a person can finish a task. I have also seen the same tools create a pile of review work when nobody agrees on what good output looks like. Faster code is useful. Clear judgment is what keeps the speed from turning into rework.
Cutler’s talk matters because it looks past the usual demo of an AI assistant writing a function. It asks a harder question: if every engineer can use similar tools, where does a staff engineer create extra value? The answer is not to hoard prompts or produce the most pull requests. It is to find repeated decisions, make them easier to apply, and leave room for the human work that cannot be automated.

What Is AI-Era Staff Engineering?
A staff engineer is a senior technical contributor whose work reaches beyond a single ticket or code change. The role often includes setting technical direction, solving cross-team problems, improving engineering practices, and helping other engineers make sound choices. The exact job varies by company, which is why a title alone tells you little. The useful question is: what problems can this person help a group solve?
AI-era staff engineering keeps that purpose but changes the available tools. An engineer can ask an agent to draft code, summarize a codebase, or prepare a migration plan. That can reduce the time spent on routine work. But a draft is not a decision. Someone still has to judge whether the change fits the system, whether the tests cover real user behavior, and whether the risk is acceptable.
That distinction is central to Cutler’s argument. In a previous talk, he described using AI to shrink a four-hour task to four minutes. He said he had reached a point where he was shipping about as much as his whole team. Then he saw the trap: he was multiplying himself, not the team. One person’s speed can be impressive, but it has a ceiling. Better team habits can keep paying off after that person moves to another problem.
The role is therefore less about being the person who writes the most code and more about shaping how work gets done. A staff engineer can test a tool before others spend time on it, capture lessons in the team’s normal workflow, or create a safe system for changes that span many files. This fits the view of staff engineering described in the StaffEng guide to what staff engineers do: technical leadership depends on the needs of the organization, not on a fixed list of tasks.
I have seen this pattern across teams. A clever engineer may know the answer, but a team benefits only when that knowledge reaches the people doing the work. Frankly, this is not new. AI just makes the gap between individual skill and shared practice harder to ignore.
Core Benefits and Importance
The strongest case for this approach is not that AI writes code. It is that good technical judgment can be used more than once. Cutler shared Pinterest data on merged pull requests per engineer per week from Q1 2025 to Q3 2026. The top 10% rose from 6.7 to 11.3, a reported 68% increase. The bottom half moved from 1.0 to 1.15, which the talk reported as a 14% increase. Using only those displayed rounded figures gives 15%; the report may use more precise underlying values. That small discrepancy is worth noting rather than smoothing over.
The larger point is the spread. Everyone may have access to AI, but access alone does not produce equal results. Some engineers know how to split work, check output, and steer an agent. Others may spend more time fixing its mistakes than they save. The answer is not to shame the slower group. It is to make useful habits easier to learn and repeat.
- More leverage from one good decision. If a staff engineer learns that a certain agent fails when it cannot be steered mid-task, sharing that finding saves other people from repeating the same failed trial. A short note can prevent a week of scattered experiments.
- Faster onboarding. New engineers should not have to learn every local rule by receiving the same review comment five times. A clear checklist, working example, or agent instruction can help them make a better first attempt.
- More consistent quality. Shared guidance can remind people to fix the cause of a null value, test a feature as a user would, and keep a pull request small enough to review. The tool does not replace judgment; it can help put judgment in front of the person who needs it.
- Time for work that needs people. Less repeated review and manual migration work can leave more room for design discussions, mentoring, and honest conversations when a teammate is struggling. That matters because software work has a human purpose. Good engineering should serve people and the common good, not turn every person into a faster ticket handler.
- A clearer way to measure progress. Teams can track cycle time, escaped defects, review load, and adoption, rather than counting generated lines of code. More output is not a win if it creates more production incidents or drains reviewer attention.
Research also argues against simple claims. GitHub reported that participants in one controlled Copilot task completed it 55% faster, but a task study is not a promise that every team will see the same gain. A METR study of experienced open-source developers found that early-2025 AI tools made participants slower on the tasks studied, even though participants expected to be faster. Context matters. Here’s the kicker: a staff engineer can help a team tell the difference between a useful tool and a shiny distraction.
See also the GitHub Copilot productivity study for the defined task and study conditions.

Step-by-Step Implementation Guide
Cutler’s three moves—multiply yourself, multiply your team, and multiply the system—make a practical starting plan. They are not three fancy labels for buying more software. Each move asks where repeated effort is getting stuck.
- Write down what you repeat. For a week, record recurring code review comments, setup questions, failed experiments, and manual tasks. Keep the notes specific. “Improve code quality” is too broad to act on. “Ask why this field can be null before adding another null check” gives an engineer something concrete to inspect.
I have found that the review queue often tells the truth faster than a planning meeting. If the same comment appears across several pull requests, it may be a gap in shared guidance, not a string of unrelated mistakes. Start with the repeat, not with a grand AI strategy.
- Try the tool on a small, bounded task. Go first, as Cutler recommends. Use a branch, a test fixture, or a sandbox where a poor result cannot damage production. Record what worked, what failed, and what extra supervision the tool needed. Cutler described an agent harness that could not be steered once a task began, and a remote runner that required too many follow-ups. Those failures are useful findings. They tell the team what not to copy.
- Turn lessons into short instructions. In repeated agent sessions, Cutler found himself giving the same corrections: avoid em dashes, include a diagram in the pull request description, and keep the pull request small. That is a clue. Move the relevant instructions into a place the agent and the engineer can see, such as a repository guide, pull request template, or task-specific prompt. Keep instructions short enough to maintain.
- Put the guidance where work already happens. A rule buried in a separate wiki is easy to forget. Add the right note to the repository, code review template, development command, or team workflow. For a new teammate, provide examples of a good test and a reviewable change. Do not make someone search through old chat messages to find a rule that affects today’s work.
- Automate one repeated case with a safety net. Cutler’s migration example shows the bigger move. Instead of asking people to apply a change manually across hundreds of files and teams, an engineer gives an agent a plan and an example; the work is scheduled, split into team-sized pull requests, and run in a sandbox. A class component migration reportedly ran three to five times faster than doing it by hand, while teams worked on other tasks. Start with one migration or one flaky-test category, not every kind of change at once.
- Measure the result and keep a human owner. Track how long the work takes, how many pull requests need repair, CI time, review burden, and any production issues. Give someone clear responsibility for stopping a runaway job. When a scheduled job opened 16 pull requests in two minutes and pushed CI wait times from under 30 seconds to 14 minutes, the team learned that a small guardrail mattered. Set limits on job frequency, pull request count, and resource use before widening the rollout.
- Expand only after the workflow behaves. Cutler encouraged engineers to find their own “any” problem: a first responder for any incident, a draft fix for any bug ticket, or a triage agent for any flaky test. The useful word is “any,” but it must not mean unbounded. Define which cases qualify, what the agent may change, and when a person must approve. At the time of the talk, 40 engineers had scheduler jobs of their own. That is a sign of adoption, not proof that every job is valuable. Review the jobs and retire the ones that no longer help.
Most guides tell teams to adopt a tool and train everyone. That skips the hard part: making the work safe, visible, and easy to repeat. Let’s be real—guardrails are part of the product, not red tape around it.
Comparison Table: Staff-Engineer Leverage vs. Individual AI Productivity
The closest alternative to this model is an individual productivity approach: give each developer an assistant and expect faster personal output. That can help. It is not the same as changing the way a team handles repeated decisions or work across many repositories.
| Area | Staff-engineer leverage | Individual AI productivity |
|---|
| Main goal | Improve how a team or system performs | Help one person finish a task faster |
| Typical work | Shared instructions, migration workflows, safe automation, technical direction | Code suggestions, chat, summaries, local task support |
| Reach | Can benefit many engineers and teams | Usually starts with the person using the tool |
| Best measure | Team cycle time, quality, review load, safe adoption | Time saved on a defined individual task |
| Main risk | A shared automation error can spread widely | A person may accept weak output or save little time |
| Good first test | A repeated task with clear limits and review | A small task with a clear answer and easy verification |
The first column does not make the second one useless. Personal tools can be the first step. Cutler’s own early use of AI helped him notice that he was multiplying only himself; the next step was to share useful corrections and build a broader workflow. This is a change in scale, not a rejection of coding assistants.
The figures from the Pinterest talk also need careful reading. A rise in merged pull requests does not prove that every change had equal value, nor does it show defect rates, product outcomes, or reviewer effort. The top group’s reported rise was much larger than the bottom half’s, but a single activity metric cannot explain why. The team’s report that it now ships about four times as much per engineer, excluding Cutler’s own pull requests, is a notable internal result. It should be treated as a result from that team, not a guaranteed result for every organization.
The DORA 2024 report gives a useful caution: AI tools work inside an organization’s existing practices, so a team’s ability to deliver still depends on the surrounding system. Compare results before and after a change, and watch both speed and quality. The truth is, a table can show the trade-off. It cannot choose the right workflow for you.
Common Mistakes to Avoid
The first mistake is treating AI access as a plan. Buying licenses or turning on an agent does not explain which problem the team is solving. Ask what repeated work is slow, what judgment is needed, and how a person will check the result. If nobody can answer those questions, start with observation instead of deployment.
The second mistake is using one engineer’s output as the whole measure. Cutler’s first breakthrough made him exceptionally productive, but he recognized the limit: the gains sat with him. A star engineer can still become a bottleneck if every decision needs their approval. Share the reason behind the guidance, not just a list of commands. Otherwise, the team may copy a rule that no longer fits the case.
The third mistake is believing agent instructions are permanent. A prompt that works on one codebase can fail in another. A rule to keep changes small is usually sensible, but a migration may need a coordinated set of changes. Keep an owner for shared instructions, test them against real examples, and remove stale rules. In my experience, old documentation can cause as much confusion as no documentation.
The fourth mistake is automating a task before defining its limits. The scheduled job that opened 16 pull requests in two minutes shows why a small first version is better than a sweeping rollout. Add a maximum number of changes, a delay between runs, a sandbox, and a clear stop switch. Monitor CI queues too. A fast agent can still slow an entire team if it floods shared infrastructure.
The fifth mistake is counting activity as value. More pull requests may mean more useful changes, or simply smaller changes, duplicated work, or extra review. Pair output counts with defect rates, rollback rates, lead time, and feedback from the engineers maintaining the code. A good measure should expose a problem, not hide it behind a large number.
The sixth mistake is trying to automate the parts of leadership that require trust. A tool can draft a code review comment; it cannot replace a careful conversation with a teammate who is struggling. Staff engineers still need to listen, give direct feedback, and protect time for real learning. The NIST AI Risk Management Framework offers a broader reminder: responsible use includes identifying risks, assigning oversight, and checking outcomes. Here’s what nobody tells you: the human owner is not a temporary weakness in the system. That person is part of how the system stays responsible.
Frequently Asked Questions
What does AI change about a staff engineer’s role?
It changes where the engineer can apply leverage, not the basic purpose of technical leadership. A staff engineer can still set direction and solve hard cross-team problems, but AI offers new ways to test ideas, share guidance, and automate repeatable work. The useful shift is from doing more alone to helping other engineers make better decisions. The human still owns the risk and the result.
Does AI make a 10x engineer obsolete?
No. It makes the old idea of a 10x engineer—one person who writes code much faster—less complete. When many engineers have access to similar tools, advantage comes from helping a team use them well. Cutler’s closing point was that a 10x engineer is not ten times faster; they are the reason ten other people can do better work. That is an aspiration, not a promise that one person can multiply every team by ten.
How should a team measure AI engineering productivity?
Use several measures, not just code volume or pull request count. Track cycle time, review effort, defects, rework, reliability, and whether engineers can spend more time on high-value work. Compare a defined workflow before and after the change. Keep the task and quality bar as similar as possible. If a speed gain comes with more defects or overloaded reviewers, the team has moved the cost rather than removed it.
What is a safe first AI automation project?
Choose a repeated task with clear inputs, clear limits, and an easy human review. Examples include drafting a change for a known bug category, sorting a specific class of flaky test, or applying a routine migration in a sandbox. Start with one narrow case. Set limits on what the agent can change, test its output, and provide a stop switch before letting it run on a schedule.
Final Thought
The most useful idea in Cutler’s talk is simple: stop asking only how much faster one engineer can code. Ask what that engineer knows that could make the next ten engineers’ work clearer, safer, or less repetitive. Sometimes the answer is a short review rule. Sometimes it is a tested migration workflow. Sometimes it is admitting that an agent is not ready for the job.
I have watched teams buy tools faster than they build habits. The tool gets the attention because it is visible. The quiet work—writing down a judgment, setting a limit, helping a new person understand the system—often creates the lasting gain. That work deserves respect. It is skilled labor, and it is a form of stewardship: using knowledge and time carefully so other people can do good work without needless friction.
A staff engineer cannot encode every part of judgment. Trust, patience, and an honest conversation still need a person. But many repeated decisions can be made easier to see and apply. That is where AI can help: not by taking responsibility away, but by carrying a sound decision farther through the team.
The test is not whether an agent can make a pull request. The test is whether the whole team can deliver useful changes with less waste and no loss of care. If the answer is yes, the staff engineer’s leverage has moved beyond personal output. That is a better kind of speed.