AI in Enterprise Software Engineering: Observations from 2026

Observations on how AI use in software engineering changed in 2026, from faster code creation and review bottlenecks to moving beyond the IDE.

At the end of last year, I shared observations on how AI was used in enterprise software engineering. At the time, AI worked well for prototyping, summarizing context, and editing, while few trusted it with production-critical code.

A year later, I use AI far more in my day-to-day engineering work. The tools got better, and the bigger shift is in process: how code changes get created, reviewed, and shipped.

What Changed

  1. Writing code got faster than reviewing it
    Engineers generate far more code changes, tests, and refactorings than a year ago. Yet AI still rarely ships straight to production unattended, because on large systems with many users even a rare incident costs a lot in engineering time and customer trust. As a result, changes still wait for human reviewers, and review queues pile up on experienced engineers who have the least time to spare. Automated review tools do not yet have enough repository and cross-service context to take over on their own. Reviewing every diff by hand, one at a time, will not scale unless the rest of the pipeline helps verify the work.

  2. Chasing noise slows adoption
    In my experience, few people object to AI anymore, yet many use only a fraction of what current tools handle well. Some engineers try to keep up with every new model, term, and workflow, and fall further behind. Standard tools are good enough to start with. What builds real momentum is teams sharing short demos and small wins in chat, like cleaning up tests or scripting a repetitive migration, instead of trying to track every release.

  3. Judgment drives outcomes and roles
    The gap between experienced and less experienced engineers is widening. Experienced engineers are getting more done than ever because they can quickly decide which generated code to keep, fix, or discard. Because sound judgment produces better outcomes, engineering roles shift further toward it, and I expect organizations to reward it even more. Less experienced engineers risk falling behind if they act as a pass-through between tools and teammates instead of using AI to build that judgment faster. I see this when an engineer pastes a senior reviewer’s comments straight into a prompt and sends back whatever comes out without understanding why, missing what the review was meant to teach.1 The same happens when someone shares a long generated document whose main point they cannot explain.2

  4. Managers own AI capacity too
    Managers already answer for turning headcount into business impact. I expect managers across the industry will answer for AI spend the same way, treating tokens as another resource a team turns into customer results. Teams can fall short on either end: under-using capable tools, or burning heavy token budgets with little customer impact while leaving behind scattered scripts and docs that neither people nor agents can follow.

  5. Vague goals compound after the prototype
    When a new project is still ambiguous, AI works well for building quick prototypes to clarify what you want. Moving past prototyping while goals stay vague is risky. Because generating more code feels effortless, teams rarely stop to throw early work away. Wrong assumptions stay in the repository, become context for the next run, and pull each iteration further off course.

Moving Beyond AI in the IDE

Using AI only inside an editor keeps a person in every small step. The next gains come from taking people out of routine steps while keeping them responsible for the outcome. Getting there takes a few shifts:

  • Move human review up to the design level: Reading every generated line in isolation quickly exhausts reviewers. Short design docs, AI-assisted or not, let people agree on core principles and trade-offs up front. Generated code then becomes closer to compiler output from that agreed plan. One big difference remains: compilers are deterministic and language models are not, so the design also has to give tests a clear target.
  • Build verification into the pipeline: Human reviewers should not have to act as linters or manual test runners. Combine test-driven development, formal validation where it fits, and automated review passes with fast tests, gradual rollouts, and quick rollbacks so agents can handle routine maintenance with higher confidence.
  • Start with safer languages and greenfield scope: Favor strongly typed, memory-safe languages where possible so compilers and static checks catch whole classes of errors before human review. Greenfield projects are also a good place to start, with less existing complexity and lower customer risk, giving teams room to build trust in automated workflows.
  • Tune the harness as much as the model: Model releases get most of the attention, yet the harness running the model (its permissions, local context, reusable task instructions or “skills,” and verification checks) affects output quality just as much.
  • Give agents narrow identities: Engineers often hold broad default permissions through their personal credentials, and an agent running under a person’s credentials inherits all of it. Giving an agent its own restricted identity makes it much safer to run background tasks or a group of agents while you step away. For example, let an agent read broadly while requiring human confirmation before it posts externally or writes to production.
  • Keep accountability with people: As the old IBM training slide says, “A computer can never be held accountable.” Agents will make mistakes, and teams need leadership backing to take bounded risks and learn from them while organizations adjust. Still, the person owning the work stays responsible for the outcome, leads the postmortem when something breaks, and puts the fixes into tests, guardrails, and agent instructions so the next run catches it.

Two personal habits have helped me build intuition. At the end of a session, I ask my harness to review what worked and update its local skills so the same mistakes do not repeat. I am also writing more code myself again. It is fun, and it is the best way to see what the tools can really do.

I am more optimistic than I was a year ago. The tools can already do much more than most of us ask of them. Most of the remaining work is in how we design, review, ship, and own what they produce. Feel free to reach out if you would like to compare notes.

Disclaimer: Opinions are my own and not the views of my employer. This post is based on my own observations, and I used AI tools to help write it.


  1. I wrote earlier about code review interviews for engineering managers, where code reviews show technical judgment and double as coaching. ↩︎

  2. From my 2025 post: “if you are going to share an AI generated document, please kindly share the prompt instead." ↩︎

Enjoyed this post? Never miss out on future posts by following me.