AI Is Reshaping Tech Jobs: Why Coding Skills Are No Longer Enough
Software engineers have traditionally competed on their ability to design systems, write code, debug problems, and deliver working products. That equation is changing.
AI coding agents are increasingly capable of handling tasks that previously required substantial engineering effort. They can generate complete applications, coordinate multiple development agents, run tests, and modify large codebases with relatively little human intervention.
Recent demonstrations involving Anthropic’s Claude Fable 5.2 illustrate how quickly these capabilities are advancing. At the same time, technology hiring data shows that companies are changing which positions they recruit for and which skills they expect employees to have.
The two developments point toward the same underlying shift: writing code is becoming a smaller part of the value an engineer provides.
Over the past few days, Anthropic engineering lead Felix Rieseberg demonstrated Saltline, a playable first-person shooter created through a single initial prompt, without subsequent human feedback. The model generated the game’s environments, visual assets, and sound effects, producing a surprisingly complete browser-based experience.
According to Rieseberg, the experiment took approximately eight hours and cost around $550 at API pricing. He also reported roughly 445 million input tokens, much of which was cached, and 2.7 million output tokens. These figures are his estimates, but they help illustrate the computational scale behind the demonstration.
That was not the only experiment.
In another demonstration described by Anthropic, an engineer asked Fable 5.2 to build an operating system from an empty directory. The model coordinated more than 1,000 sub-agents over eight days. Those agents wrote, tested, and reviewed code throughout the process.
The resulting prototype could boot on a laptop and included a kernel, device drivers, persistent storage, window management, a login screen, and an installer.
Anthropic also reports that more than 90% of changes merged into its core codebase are now written by Claude, with human guidance. In another engineering project, a team of agents migrated a critical production service from Python to Rust. According to Anthropic, the resulting service starts approximately 26 times faster.
These results deserve attention, but they need some qualification. A prototype operating system is not equivalent to a production-ready operating system. Similarly, successfully generating a large codebase does not demonstrate that an autonomous agent can independently maintain a complex service for years.
The broader direction is nevertheless difficult to ignore. AI systems are moving beyond autocomplete and isolated code generation toward coordinating substantial engineering projects.
For software professionals, this raises a practical question: if AI can increasingly build applications, games, and operating-system components, what capabilities will distinguish experienced engineers from everyone else?
A report from Lenny’s Newsletter, titled State of the Tech Job Market: Late 2026, provides useful context. It combines global job-opening data from TrueUp, which tracks more than 9,000 technology companies, with U.S. hiring data from Live Data Technologies, covering career changes across 124 million professionals.
The findings reveal a complicated employment picture. Engineering remains the largest technical hiring category, but actual hiring has slowed. Product design and user research have weakened considerably, while forward deployed engineering and security engineering are receiving more attention.
This is not simply a story about AI replacing developers. Companies are changing how they organize engineering work, distribute responsibilities, and decide where additional employees create measurable value.
📊 Tech Hiring Is Growing, but Engineering Demand Is Losing Momentum #
One of the most useful distinctions in the report is the difference between job openings and actual hires.
Job openings indicate what employers are advertising. Hiring data shows how many people actually enter those organizations. The two measurements can tell very different stories.
At first glance, technology hiring demand still appears relatively healthy. Since the beginning of 2023, product management openings have increased 56%, while engineering openings have grown 43%.
However, the growth rate for engineering positions has slowed substantially:
- Engineering openings increased 29% through 2024.
- Growth declined to 15% through 2025.
- Over the latest year covered by the report, growth slowed to approximately 2.5%.
The number of open engineering positions at tracked technology companies is now lower than it was in March 2026.
Actual hiring presents an even less encouraging picture.
U.S. companies hired approximately 113,000 software engineers between May 2025 and April 2026. That is less than half the 2022 peak of approximately 239,000.
Since January 2024, engineering openings have increased 44%, while actual hiring has declined 17%.
The gap matters because an advertised position does not necessarily translate into a new employee. Hiring freezes, longer recruitment cycles, stricter selection criteria, and unfilled requisitions can all contribute to the difference.
The report does not establish that AI is solely responsible for this slowdown. Economic uncertainty, corporate cost controls, and changes in organizational structure are also relevant.
Nevertheless, the data suggests that the previous approach of continuously expanding engineering teams to increase software output has lost momentum.
Engineering remains the largest hiring category, with more than 65,000 active openings. Companies still need engineers. What appears to be changing is their willingness to add headcount without a clear connection between additional employees and business results.
Why more job openings do not necessarily mean more hiring #
Technology companies can advertise positions while simultaneously becoming more selective about candidates.
For example, a company might previously have hired several engineers to implement separate application features. Today, an experienced engineer using coding agents may be able to handle much of that implementation work independently.
The organization may still need the position, but its expectations will change.
Instead of primarily looking for someone who can implement a predefined task, hiring managers may prioritize candidates who can:
- Translate business requirements into technical architecture.
- Coordinate AI-assisted development workflows.
- Review and validate generated code.
- Diagnose production problems.
- Make decisions involving performance, security, and maintainability.
- Take ownership of an entire feature or service.
This changes the hiring equation. A smaller engineering team can potentially deliver more output, but each engineer is expected to operate with greater independence.
🎨 Product Design and User Research Are Facing Greater Pressure #
Among the five core product functions tracked in the report, product management has been relatively resilient.
Its share of actual U.S. hiring across those five functions increased from 16% in 2021 to 21% in the latest reporting period. It is the only category whose share increased.
That does not mean product management hiring is booming. Actual hiring across core product roles has generally remained flat or declined. PMs have simply performed better than the other functions.
Product design and user research have experienced much sharper contractions.
Product design hiring #
The report identifies several indicators of declining demand:
- Approximately 1,900 product design openings remain at tracked technology companies globally.
- Openings are down 28% year-over-year, reaching the lowest level in the report’s tracking history.
- U.S. companies hired approximately 12,600 product designers over the past year, compared with 27,600 in 2022.
User research hiring #
The decline is even more pronounced for user researchers:
- U.S. companies hired approximately 1,800 user researchers over the past year.
- That represents a 66% decline from approximately 5,300 hires in 2022.
- Only around 108 user research openings remain at tracked technology companies globally.
These numbers do not prove that AI directly eliminated those positions. Product organizations are also responding to cost pressures, faster release cycles, and changing expectations about how design and research work should be distributed.
However, AI changes the economics of producing early-stage product work.
A product team that previously needed several specialists to create an initial prototype can now use AI tools to generate interface layouts, write frontend code, create test cases, and iterate on implementation.
When requirements are well-defined and results are relatively easy to verify, a smaller team can complete work that previously required more people.
This puts pressure on positions centered primarily on repeatable execution. It does not make the underlying disciplines unnecessary.
A generated interface still needs to be usable. A prototype still needs to address the correct problem. An implementation that passes automated tests can still frustrate customers or fail under real operating conditions.
Why product judgment still matters #
The relative resilience of product management reflects an important distinction.
A product manager’s job is not simply to coordinate developers or maintain a backlog. It involves deciding which problems deserve attention, evaluating competing requirements, understanding customers, and determining whether the resulting product creates meaningful value.
AI can help with market research, requirement drafting, prototyping, and documentation. It can even generate implementation plans and suggest product improvements.
But producing a technically functional feature is not the same as establishing that the feature should exist.
As implementation becomes cheaper, the quality of product decisions becomes more visible.
The same principle applies to design and research. Automated tools can produce interface variations and summarize feedback, but interpreting ambiguous user behavior and understanding why people struggle with a product remain demanding tasks.
The work is changing from manually producing every artifact toward directing, evaluating, and improving what AI systems generate.
🧭 Forward Deployed Engineers Are Becoming More Important #
One of the most interesting findings in the report is the growth of Forward Deployed Engineers (FDEs).
Global FDE openings have increased approximately 4.6 times over the past year, reaching around 1,500 positions. Security engineering is another specialty attracting increasing attention.
There is an important qualification: some of the reported growth may reflect existing positions, such as sales engineering, being renamed or reclassified as FDE roles. The figures should not be interpreted as entirely new demand.
Even with that caveat, the trend highlights a meaningful change in engineering requirements.
What does a Forward Deployed Engineer actually do? #
An FDE works close to customers, helping adapt software to real business requirements and operational environments.
The position combines software engineering with product understanding, customer interaction, and practical deployment experience.
Typical responsibilities include:
- Understanding workflows that were never formally documented.
- Integrating software with legacy systems and inconsistent datasets.
- Translating vague business requirements into technical specifications.
- Handling unusual infrastructure and deployment constraints.
- Debugging failures in environments the product team does not fully control.
- Identifying gaps between the intended product behavior and actual customer needs.
- Ensuring that a technical implementation produces measurable business value.
These responsibilities are difficult to reduce to a straightforward coding prompt.
An AI agent may generate an integration quickly, but it still needs accurate information about the customer’s systems, data structures, permissions, and operational constraints.
Someone must determine whether the integration is correct and whether the resulting workflow actually solves the customer’s problem.
That is where an FDE provides value.
Why AI can increase demand for customer-facing engineers #
At first, the growth of FDE positions may seem counterintuitive.
If AI can write more code, why would companies need additional engineers working directly with customers?
The answer is that producing software and deploying it successfully are different problems.
When implementation becomes cheaper, organizations can experiment with more projects and attempt more customized deployments. However, each successful deployment still needs to fit into an existing business environment.
A coding agent can generate an application. It cannot automatically know which undocumented business process must be preserved, which legacy database contains the authoritative records, or which operational constraints make a seemingly simple integration difficult.
Those details require investigation and judgment.
The broader trend is that engineering work is moving closer to the point where software produces business value.
Security engineering follows a similar pattern #
Security engineering is gaining attention for related reasons.
Autonomous agents can read files, modify source code, execute commands, call external tools, and interact with enterprise services.
That creates additional questions:
- Which files and services can an agent access?
- How should agent identities and credentials be managed?
- Can an agent expose confidential information through an external tool?
- How are actions recorded and audited?
- What happens when an agent executes an incorrect operation?
- Which actions require explicit human approval?
The more authority an agent receives, the more important its permission boundaries become.
This is not simply a matter of adding another authentication layer. Agent-based systems need clear authorization models, scoped credentials, execution controls, and reliable audit trails.
Three capabilities that are gaining value #
FDEs, security engineers, and product managers work in different areas, but their value increasingly centers on three capabilities:
- Judgment: Deciding what should be built, which trade-offs are acceptable, and how a system should behave.
- Verification: Establishing whether the result is correct, secure, maintainable, and useful.
- Real-world integration: Making software operate reliably within actual business and infrastructure environments.
AI will continue improving in all three areas. However, delegating them completely remains difficult when failures can affect customers, financial transactions, security, or production operations.
🏢 Tencent Is Rethinking How Its Workforce Operates #
Similar organizational questions are emerging among major Chinese technology companies.
During Tencent’s 28th-anniversary internal livestream, management discussed how the company should adapt to the AI era.
Its existing core businesses were compared to an Army, while new AI-native businesses were compared to a Navy.
The proposed organizational analogy suggested that roughly half of employees should operate like the Army, applying AI to improve established businesses, while the other half should operate like the Navy, exploring new AI-native opportunities.
The comments quickly triggered rumors that Tencent was planning to lay off 50% of its workforce.
Tencent PR Director Zhang Jun rejected those claims, explaining that the comparison was a metaphor for resource allocation and organizational adaptation, not an announcement of plans to halve headcount.
The more interesting issue is the management philosophy behind the analogy.
For years, large technology companies have focused heavily on reducing operating costs and improving efficiency. In the AI era, the challenge is increasingly about getting more value from existing teams while directing resources toward new business opportunities.
That can involve:
- Giving frontline employees broader ownership of business outcomes.
- Reducing unnecessary management layers.
- Encouraging teams to experiment with AI-native products.
- Integrating AI into established business workflows.
- Moving resources toward projects with stronger growth potential.
It also reflects a broader change in how companies measure organizational capacity.
If AI allows a smaller group of engineers to deliver more software, simply increasing headcount to increase output becomes less attractive.
However, efficiency gains do not automatically create new business opportunities.
Companies still need employees who can identify valuable problems, understand customers, make decisions, and take responsibility for the resulting products and services.
The organizational challenge is not merely reducing the number of people required to write code. It is deciding where human expertise produces the greatest return.
🛠️ AI Proficiency Is Becoming a Baseline Job Requirement #
The hiring report also examines how the skills listed in technology job descriptions have changed.
The shift is particularly visible in product management.
Two years ago, common PM requirements included SQL, Jira, AWS, and Python. In the latest report, LLM is the most frequently mentioned skill in product manager job descriptions.
Other AI-related terms have also moved up the rankings:
- Claude is the third most frequently mentioned term.
- Cursor, OpenAI, and MCP appear among the top eight.
- Evals, referring to the systematic evaluation of model outputs, has entered the top 10.
Engineering job descriptions show a similar transition.
Python remains the most frequently mentioned engineering skill, but LLM has now overtaken Java.
Design requirements are changing as well. Figma remains highly relevant, but Claude has become the second most frequently mentioned skill in designer job descriptions, moving ahead of CSS. Cursor has also moved past CSS.
These changes indicate that AI tools are no longer limited to experimental teams or developers who enjoy testing new technology.
They are becoming part of the standard toolkit across product, engineering, and design.
What AI proficiency actually means for developers #
For software engineers, knowing how to use coding agents is increasingly expected.
Tasks that once required several days to produce an initial implementation may now take only a few hours. Tools such as Claude Code and Cursor can inspect repositories, modify multiple files, run commands, and help developers work through complex implementation tasks.
However, faster code generation introduces a different set of engineering responsibilities.
Consider the following questions:
- Is the generated code functionally correct?
- Does it introduce security vulnerabilities?
- Does the implementation match the actual requirements?
- Can another engineer maintain the code?
- How should an autonomous agent’s access to production systems be restricted?
- Who is accountable when an agent makes a damaging change?
A developer who can generate code quickly but cannot evaluate it is not necessarily more productive.
In some cases, that developer may simply produce technical debt at a higher speed.
The ability to inspect, test, and challenge AI-generated output is becoming as important as the ability to produce it.
AI-assisted development still requires engineering fundamentals #
Experienced developers should not interpret this shift as a reason to abandon traditional engineering knowledge.
Understanding data structures, networking, operating systems, databases, concurrency, distributed systems, and software architecture remains valuable.
In fact, these fundamentals become more useful when an AI agent can generate implementation details faster than a human can inspect them.
A developer who understands transaction isolation can identify a database bug that an agent overlooked. Someone familiar with distributed systems can recognize why a generated retry mechanism might cause duplicate operations. An engineer who understands memory management can investigate performance problems that are not immediately visible in application-level tests.
AI reduces the amount of code developers need to write manually. It does not remove the need to understand what that code does.
For a practical perspective on working with AI coding tools in large repositories, see Effective Claude Code Integration for Large Codebases. The central engineering lesson is that repository structure, build procedures, testing conventions, and permission boundaries still need to be communicated clearly to an agent.
🤖 Software Must Now Serve Both Humans and AI Agents #
The changing skill requirements point toward a deeper architectural shift.
Traditional software has largely been designed around human interaction.
Users open applications, navigate menus, click buttons, complete forms, and execute workflows through graphical interfaces.
AI agents introduce another type of software consumer.
They need structured ways to discover capabilities, access information, and execute operations. APIs and protocols such as the Model Context Protocol (MCP) provide interfaces through which agents can interact with software without relying entirely on visual controls.
This means software increasingly needs to support two categories of users.
1. AI agents #
Agents need predictable interfaces, structured data, explicit permissions, and machine-readable responses.
They should be able to perform supported operations through documented interfaces rather than simulating every human interaction.
For example, an agent integrating with an accounting platform should be able to retrieve transaction records, inspect invoice details, and prepare supported operations through authorized API calls.
The interface must clearly define what the agent can access and which operations it can execute.
2. Human users #
People still need graphical interfaces to inspect results, understand what happened, handle exceptions, and make decisions that should not be delegated to an automated system.
This does not mean graphical user interfaces are disappearing.
It means they are no longer necessarily the only interface a product needs.
Designing software for human-agent collaboration #
Consider an expense-management application.
A human employee might review receipts, approve reimbursements, or investigate unusual transactions through the graphical interface.
An authorized AI agent could perform several routine operations:
- Classify incoming receipts.
- Extract transaction amounts and dates.
- Match receipts against expense records.
- Identify missing information.
- Prepare reimbursement requests.
- Flag transactions that violate company policies.
The agent handles routine processing, while the human retains control over sensitive approvals and exceptions.
This architecture requires more than exposing a few API endpoints.
It needs:
- Identity management for users and agents.
- Scoped permissions and authorization policies.
- Structured API contracts.
- Audit logs covering agent actions.
- Idempotency for operations that may be retried.
- Reliable error handling and recovery.
- Human approval for sensitive or irreversible operations.
For example, an agent that prepares a reimbursement request should not automatically receive permission to transfer money. Reading transaction records, creating draft requests, approving expenses, and executing payments are different permission levels.
The distinction becomes increasingly important as agents gain access to enterprise systems.
MCP and the changing developer workflow #
MCP provides a standardized way for AI applications to discover and invoke external tools and resources.
For developers, this creates opportunities to expose existing application capabilities to AI agents without designing a separate integration mechanism for every model or client.
However, MCP does not eliminate the need for sound API design or security engineering.
A poorly designed tool interface remains difficult to use, regardless of whether the caller is a human-written application or an AI agent.
Developers still need to define clear input schemas, validate parameters, enforce authorization, handle failures, and prevent unintended side effects.
For a deeper look at the architecture behind autonomous development workflows, see DeepSeek Super-Agent: Multi-Agent Architecture and AI Automation. Its discussion of routing, worker agents, task scheduling, and execution isolation illustrates how software systems are evolving to coordinate increasingly complex agent workflows.
As AI capabilities improve, enterprise software will increasingly be evaluated not only by how well people can use it, but also by how safely and reliably autonomous agents can operate it.
🧠 AI Can Write Software, but That Doesn’t Mean Software Engineers Are Disappearing #
Claude Fable 5.2 demonstrates how much software development can now be delegated to autonomous coding systems. But a model demonstration and a labor-market report measure different things. Neither should be treated as definitive proof of what will happen to software engineering employment.
The hiring data shows that engineering demand has slowed, product design and user research hiring have contracted, and specialized roles such as forward deployed engineering and security engineering are attracting more attention.
AI is part of this changing environment, but economic conditions, corporate spending, and organizational restructuring also influence employment.
Taken together, the developments point toward several changes in how technical work is valued.
Code generation is becoming cheaper #
Generating an initial implementation is no longer the main bottleneck for many software projects.
AI agents can produce large amounts of code, create application prototypes, and handle routine implementation tasks. This changes how much engineering effort companies need to allocate to basic execution.
Prototype development is accelerating #
Smaller teams can explore more ideas without manually implementing every component.
This can shorten development cycles and make experimentation less expensive. However, prototypes still need to be evaluated before they become production systems.
Execution-heavy roles are under pressure #
Work with clear requirements and easily verifiable results is increasingly suitable for automation.
This includes repetitive code generation, basic test creation, documentation, routine refactoring, and straightforward application development.
The pressure will not affect every engineering discipline equally. Work involving complex systems, ambiguous requirements, production operations, and security has different constraints.
Cross-functional ownership is becoming more valuable #
Engineers are increasingly expected to understand product requirements, customer workflows, infrastructure, and operational risks.
The ability to take a feature from an unclear business problem to a reliable production deployment can be more valuable than simply implementing an assigned task.
AI governance is becoming an engineering responsibility #
As agents gain access to repositories, databases, cloud infrastructure, and enterprise services, controlling their behavior becomes part of system design.
Permissions, evaluations, monitoring, security, and accountability can no longer be treated as secondary concerns.
The transition will not benefit every worker equally #
It is also worth resisting the assumption that every shrinking role will automatically be replaced by a new, higher-paying position.
AI can reduce the number of people required for certain tasks without generating an equivalent number of new jobs elsewhere.
Some professionals will need to change their technical skills, take on broader responsibilities, or move into different areas of the industry. Others may face direct employment pressure.
The transition is likely to be uneven across companies, industries, and experience levels.
For software engineers, the practical response is not simply to learn another AI coding tool.
It is to become better at defining problems, evaluating generated work, understanding system behavior, and delivering software that survives contact with real users and production infrastructure.
For product managers, designers, and other technical professionals, the same principle applies. AI proficiency is becoming a baseline requirement. The differentiator is how effectively someone can use these tools while taking responsibility for the outcome.
Software development is becoming easier to start. Building something people can trust is still hard.
The value of technical work is shifting away from who can write the most code and toward who can define the right objectives, make sound engineering decisions, integrate systems, and remain accountable when things go wrong.
