Software engineers in the AI era face two apparently conflicting signals: entry-level hiring looks vulnerable in some data, while official forecasts still project growth in software jobs. Neither number tells an individual engineer what will happen to their career. They measure different populations and different periods.
📑Table of Contents
- What the employment numbers do—and do not—tell you
- Follow the work past code generation
- Keep accountability with people and organizations
- Test productivity without confusing output with delivery
- Make the junior path a design requirement
- Build a career portfolio, not a single prediction
- Author’s perspective
- Decide what would change your plan
A useful response is to build skills that remain useful across several outcomes, and to ask whether an employer is investing in the next generation of engineers—not just measuring how much code an AI tool can produce.
What the employment numbers do—and do not—tell you
The Stanford Digital Economy Lab’s August 2026 analysis uses US ADP payroll records to compare occupations with different exposure to AI. By June 2026, employment among 22- to 25-year-olds in highly exposed occupations was about 19% below where it would have been had it kept pace with similarly aged workers in less-exposed occupations. That is a relative gap across occupations, not a 19% fall in software engineering jobs. The authors discuss reasons AI may matter, but their comparison does not establish AI as the sole cause.
The US Bureau of Labor Statistics, meanwhile, projects 10% employment growth from 2025 to 2035 for software developers, quality assurance analysts and testers combined. Its separate projection for software developers is also 10%. A projection is not a count of openings for new graduates today, and an aggregate can grow even if some firms cut particular roles.

If you are job hunting, inspect the work behind a vacancy: who reviews changes, whether junior staff own bounded tasks, how on-call support works, and what the company expects an engineer to learn. If you manage a team, compare applications, interviews, offers and retention by experience level before concluding that an automation tool has changed hiring needs.
Follow the work past code generation
A coding assistant can suggest an implementation, explain unfamiliar code or produce test cases. The engineering work still includes deciding what behavior is wanted, checking whether a change fits the system, deploying it safely and investigating failures. The amount of human work at each step depends on the task and the tool.
| Decision | Example question for the engineer |
|---|---|
| Scope | Which user behavior must the change preserve? |
| Verification | What failure would this test miss? |
| Release | Who can approve and reverse the change? |
| Maintenance | What evidence will help diagnose a later incident? |
Imagine a change to account permissions. Ask the assistant for a small patch and possible tests; then check whether a user could access another account, whether existing clients still work and how to reverse the change. An automatically passing test is useful evidence, but it is not the whole release decision.
METR’s 2026 maintainer-review study illustrates the distinction. Four maintainers from three open-source repositories reviewed 296 AI-generated pull requests from a subset of SWE-bench Verified. Automated test success and hypothetical maintainer acceptance differed. The study used older models and a limited benchmark, without a chance for agents to revise after feedback or access to CI during review. It cannot supply a rejection rate for today’s production software.
For a closer look at a related problem, see Understanding Debt in the AI Coding Era. For the separate question of whether engineers should move toward requirements and design, see Should Engineers Shift to Upstream Work?.
Keep accountability with people and organizations
More capable AI may take on more of the work described here. The list is not a prediction of tasks AI can never perform; it is a practical way to keep decisions and accountability with people and organizations. Authority varies: an engineer may advise, while a product owner, incident lead or another authorized person makes the decision.
- Understand the people affected:An assistant can summarize interviews or suggest questions. People can speak with users and others affected, check the context, and find constraints a request leaves out.
- Choose what matters:AI can compare options. People and stakeholders must weigh competing needs—for example, accessibility, cost and delivery time—and agree which requirements take priority.
- Accept risk and authorize release:AI can assemble test results and flag potential failure modes. The person with authority decides whether the remaining risk is acceptable, whether safeguards and rollback are sufficient, and whether to release or wait.
- Respond when a service fails:AI can help search logs and suggest causes. Incident responders check the evidence, coordinate recovery and communicate with affected users, escalating decisions beyond their authority.
- Develop people and resolve disagreements:AI can draft feedback or training exercises. Senior engineers and managers create opportunities to practice, give feedback, and help stakeholders reach an agreement when their priorities conflict.
The NIST AI Risk Management Framework addresses defined roles and accountability for managing AI risks. The examples above are practical suggestions, not findings that NIST has proven AI will always be unable to perform these tasks.
Test productivity without confusing output with delivery
A local experiment is more useful than adopting a universal productivity multiplier. Track comparable changes from the start of work to release, including review and rework. Record the task type, who did it, the tool and model, elapsed time, review waiting time, follow-up fixes and any post-release problems. Avoid sending sensitive code or customer data to a service unless your organization permits it.
The need for context is visible in METR’s 2025 randomized study: 16 experienced developers worked on 246 issues in familiar large open-source projects. Tasks for which AI use was allowed took 19% longer, on average, with the early-2025 tools used in the experiment. That does not establish a slowdown for all developers or for current models.
In a February 2026 update, METR said its later experiment was affected by selection and measurement problems, including developers declining to participate because they did not want to work without AI. The researchers considered it likely that developers were more sped up than in the earlier setting, but said the data gave only weak evidence about the size of the improvement.
A small team comparison will also be noisy. Harder tasks may land disproportionately in one group; reviews can be delayed by unrelated priorities; and tools change. Use the observations to identify bottlenecks and decide what to test next, not to rank individual employees from a handful of tickets.
Make the junior path a design requirement
A junior engineer needs opportunities to diagnose, implement, receive feedback and revisit a decision. A team can use AI while keeping those opportunities visible.
Anthropic’s short experiment recruited 52 mostly junior engineers with Python experience who were unfamiliar with the target library. Participants were assigned to an AI-assisted or hand-coding condition. The AI group averaged 50% on a subsequent comprehension quiz, versus 67% for the hand-coding group. The study’s analysis of interaction styles was observational, so it does not prove that any particular prompting habit caused better learning or will produce the same result over a career.
For example, a team could ask a junior engineer to investigate a form that errors when an optional field is left blank. The engineer reproduces the bug and identifies the expected behavior, using AI for possible causes or fixes if useful. They then check the suggestions against the code, write tests for both blank and filled-in values, and verify the fix.
In review, the junior explains the cause and the change; a more experienced reviewer offers feedback, discusses alternatives and helps investigate anything unclear. Later, they can work through a related problem with different conditions. The aim is to give the junior practice investigating and verifying a change, even when AI helps. This is a suggested exercise, not an intervention proven by the study.
Managers should reserve review time and assign progressively broader responsibilities. Track whether newer engineers get to own changes, investigate incidents with support and explain tradeoffs—not just how many tasks they close. If release targets consume all the time allocated to mentoring, change the workload or schedule rather than assuming the learning happened.
Build a career portfolio, not a single prediction
Being accountable for a change takes more than knowing how to prompt an assistant. Engineers need practice understanding a problem, evaluating evidence and explaining decisions. Teams can make that practice possible by protecting time for review, giving people access to context and making decision rights explicit.
Elicit and write requirements. To decide what a change should do, ask users about their work, constraints and exceptions. For a form, observe how it is used and write examples for empty or invalid fields as well as the normal path. An assistant can suggest interview questions; the engineer checks the answers with the people affected. Managers can arrange access to users and set aside time for a product owner or experienced engineer to review the resulting requirements.
Understand the domain and set priorities. A request makes more sense when you know what happens before and after the screen or service being changed. Practice mapping the workflow with someone who does the work. If a team proposes removing a form field, check the time it saves against information needed downstream and any safety concerns. Write down the tradeoffs and the reason for the proposed priority. The organization should make domain experts available and identify who has authority to settle competing priorities.
Compare designs. To choose an implementation, engineers need to assess alternatives against constraints such as maintainability, performance, cost and failure impact. For a small change, sketch an option that extends the existing system and another that introduces a new component; explain the assumptions and unresolved risks in review. AI can suggest alternatives, but the engineer should check them against the actual system. Managers can budget for design review and expand an engineer’s decision-making scope as they gain experience.
Read code and verify behavior. A passing test alone does not explain whether a generated patch fits the system. Trace the existing code, identify expected behavior and write tests for plausible failures. For an account-permission change, test both a permitted user and a user attempting to access someone else’s data. Explain what those tests cover and what still needs inspection. Reviewers should show how they investigate gaps, while managers allow time for revision rather than counting only completed patches.
Assess security and release risk. Learn to identify sensitive information, access boundaries, affected users, detection methods and rollback options. If an engineer suspects an authorization gap, they should be able to pause the change, investigate and present the remaining uncertainty to the release approver. The organization must name who can approve or delay a release and provide a way for any team member to raise a concern. Responsibility for accepting risk should sit with someone empowered to make that decision.
Investigate incidents and operate services. Practice forming hypotheses from logs, monitoring and recent changes, then separating evidence from speculation. In an exercise, compare the time errors increased with recent deployments and work out a recovery and user-communication plan. An assistant may suggest causes, but responders verify them against the evidence. Teams should schedule drills and reviews, pair less experienced responders with experienced colleagues, and provide escalation contacts and relief during incidents.
Explain decisions, resolve disagreements and develop others. When delivery time and safety compete, present the options, unknowns and consequences of delaying or releasing in stages to the product owner and release approver. Practice recording the decision and the reasons others can revisit later. In review, a junior engineer can explain their reasoning and a senior engineer can respond with specific feedback and alternatives. Managers need to include mentoring in workload planning and provide a route for resolving disagreements.
Engineers can keep a work sample describing the problem, decision, tests and rollback plan, including where AI helped. Remove customer data and confidential information before sharing it outside the organization. These skills are ways to exercise judgment and keep learning, not a guarantee of any particular job.
Author’s perspective
The author believes engineers need to bring domain knowledge and an understanding of computer architecture together when choosing how to use AI. An assistant may know a great deal about an industry, yet still lack access to constraints or practical know-how that never appear in public material. People need to draw that context out of those doing the work and apply it to the decision.
Consider a hypothetical inventory system for a manufacturer. If staff explain that shipments must continue during network outages, a design that requires a constant connection may be less suitable than one that holds data locally and synchronizes later. The latter brings its own questions: how much delay is acceptable, and how will conflicting records be resolved safely? This is an example, not an account of the author’s experience.
Making that choice calls for more than industry knowledge alone or technical understanding alone. An engineer needs to connect the two: understand how processing and data move through the system, then weigh performance, safety and other tradeoffs against the working conditions, including when assessing an AI-generated proposal.
The author also sees room for these knowledge constraints to ease if the AI ecosystem becomes more sophisticated, including better coordination between AI systems and ways to share knowledge. That is a possibility, not a prediction of a particular capability or date; the author expects such development to take considerable time.
Decide what would change your plan
For a low-risk pilot, agree on the information the tool may access, a reviewer, the success measures and a stop condition before starting. Stop a change pending human review if it exposes sensitive information, crosses an authorization boundary or cannot be explained well enough for its risk. After an agreed period, review the quality and workload evidence alongside delivery time; adjust the pilot if review queues, defects or training time worsen.
Revisit the decision when the task mix, model, staffing or evidence changes. The future distribution of engineering jobs is uncertain; maintaining the ability to build, investigate and learn gives both individuals and teams more options while that evidence develops.
Author
Over 20 years in the IT industry, serving as Division Head and CTO at multiple companies running large-scale web services in Japan. Experienced across Windows, iOS, Android, and web development. Currently focused on AI-native transformation. At DevGENT, sharing practical guides on AI code editors, automation tools, and LLMs in three languages.
🔥 Most Popular










Leave a Reply