Two Years of AI-Assisted Engineering: What Actually Changed?

The inflection point is now approximately two years behind us. In early 2024, AI coding tools went from "useful for specific tasks" to "a meaningful part of daily engineering practice" at companies across the industry. GitHub Copilot had crossed 1 million paid users. Cursor had launched its agent mode. Claude and GPT-4 were being used directly in IDEs via extensions. The discourse was loud, the predictions were confident in both directions, and the actual evidence was sparse because the tools were new.

Two years provides enough time for real patterns to emerge, for enthusiastic early adopters to run into real limitations, and for skeptics to be either vindicated or forced to update. Here's what the evidence actually shows.

What's Been Fully Delegated

Some tasks have moved cleanly to AI and stayed there. Engineers who have made the transition report that they rarely write these things from scratch anymore:

Boilerplate and scaffolding: Creating a new REST endpoint with authentication middleware, rate limiting, request validation, and error handling — following the patterns established in an existing codebase — is something AI does well and fast. The key phrase is "following existing patterns." Code generation that matches an existing codebase's conventions is far more reliable than green-field generation.

Test writing for existing functions: Generating unit tests for pure or near-pure functions is now nearly universal among engineers who have adopted AI tools. The tests aren't always complete, and they often miss edge cases that require domain knowledge, but they provide a working starting point in a fraction of the time.

Documentation: Docstrings, inline comments, API documentation, README sections. Engineers almost universally report that documentation quality has improved since they started using AI — not because the AI writes better than humans, but because the friction of writing documentation dropped enough that it actually gets written.

Data transformation and glue code: Writing a function that maps from one data structure to another, parsing a specific file format, transforming API responses — these are tasks where AI produces correct code most of the time on the first try.

SQL queries: Generating SQL from a natural language description of what you want, given a schema, has become one of the highest-confidence AI delegation tasks. Engineers who work with databases report that AI-generated SQL is correct for medium-complexity queries about 80% of the time.

What Still Requires Human Judgment

The failure modes that haven't been solved after two years of widespread adoption:

Architectural decisions remain entirely human. Whether to use event-driven or request-response patterns, how to structure service boundaries, when to introduce a queue, how to handle distributed transactions — AI tools provide opinions but they're not reliably better than the engineer using them. The decisions that define the shape of a system are still human decisions.

Root cause analysis for complex bugs is inconsistently handled. For bugs in isolated functions with clear test cases, AI-assisted debugging is valuable. For bugs that emerge from unexpected interaction between systems — a race condition under specific load conditions, a bug that only reproduces with a specific sequence of user actions — the diagnostic reasoning required is still primarily human.

Security-sensitive code is an area where AI assistance requires the most caution. AI-generated code frequently introduces subtle security vulnerabilities: SQL injection via string concatenation, CSRF vulnerabilities in state-changing endpoints, insecure deserialization, and improper authentication checks. Teams that have had security incidents involving AI-generated code have implemented review policies specifically for this.

Performance-critical paths require human analysis. AI can generate code that works correctly but is algorithmically inefficient in ways that only surface under load. An O(n²) implementation that passes all tests at development scale but fails in production is a category of bug that AI tools generate more often than experienced engineers writing carefully.

How Code Review Has Changed

This may be the most interesting structural change: code review is now reviewing more code, but differently.

Volume has increased. AI tools enable engineers to write more code faster, which means more code is submitted for review. Review queues have grown at teams that adopted AI tools without adjusting their review processes.

The nature of review has shifted. Senior engineers who used to catch "this function is missing validation" are now catching "this entire service is architected incorrectly" — because AI handles the former well but not the latter. Review is more focused on design and correctness at the system level than implementation detail at the function level.

The AI-reviewing-AI problem has emerged at teams using AI in both code writing and code review. Reviewers using AI tools to assist review tend to approve AI-generated code more quickly because the AI assistants don't flag patterns that other AI assistants generate. Teams with strong security and performance requirements have recognized this and instituted human-only review for certain categories of change.

Have Junior Developer Roles Evolved?

This is the most politically charged part of the conversation and also the area where the data is most interesting. Hiring for junior software engineer roles slowed measurably in 2024 at several large technology companies. The connection to AI tool adoption is stated as a factor in some public communications, though separating it from broader economic conditions is difficult.

The evidence for what's actually happening inside engineering teams: the tasks that traditionally constituted junior developer work — implementation of well-specified features, bug fixes in clear cases, test writing — are now completed faster by everyone using AI tools. This has reduced the volume of "I need a junior to implement this spec" work, which changes the nature of what junior roles are for.

What's emerging, at least at the teams observed closely, is a bifurcation: junior engineers who adopt AI tools effectively and focus their learning on the judgment skills (architecture, debugging, security) that AI doesn't replace are advancing faster than before. Junior engineers who use AI as a crutch for code writing without developing underlying understanding are getting stuck when they encounter the problems AI can't solve. The distribution of junior engineer performance has widened.

The New Skills That Actually Matter

Two years of observation at real engineering teams points to the skills that have become more valuable since AI tools became ubiquitous:

Prompt precision and context management: Engineers who can describe what they want specifically and provide the right context get dramatically better AI output than engineers who give vague instructions. This is a skill that can be taught and that separates effective AI users from ineffective ones.

Code review at scale: As noted, reviewing more code efficiently — especially reviewing AI-generated code for architectural correctness and security — is more important than it was.

System-level debugging: The problems that AI can't solve are the ones that require understanding the whole system. This skill, always valuable, has become more differentiated.

Specification writing: The quality of AI output is directly correlated with the quality of the spec provided to it. Writing clear, complete specifications for features has become more valuable as a skill.

The Honest Productivity Assessment

Overall engineering productivity has increased, but not as dramatically as the most optimistic predictions suggested. Teams report 20-40% faster feature delivery on well-specified work. The gains are concentrated in implementation speed. Design, planning, debugging complex issues, and cross-team coordination have not sped up commensurately.

The tools are genuinely useful. The workflow has genuinely changed. The job has not been automated. The craft has evolved in a direction that puts more premium on judgment, system thinking, and the ability to direct AI effectively — while reducing the premium on the ability to type implementation code quickly. That's a real change, and it's one that will continue as the tools improve.