by Chris Lyons

AI in Engineering: What It’s Very Good At - and What It’s Not

There’s a lot of noise right now about AI replacing engineers, autonomous agents building entire systems, and 10x productivity claims.

After spending real time integrating AI deeply into engineering workflows, here’s my grounded take:

  • AI is extremely powerful in constrained environments.
  • It is not a substitute for engineering judgment.
  • Understanding that distinction is what separates leverage from entropy.

Where AI Is Very Good

1. Prototyping, Boilerplate, POCs, and MVPs

AI dramatically compresses the time from idea → working artifact.

Need:

  • A CRUD API scaffolded?
  • A frontend form wired to an endpoint?
  • A mock dashboard with seeded data?
  • A proof-of-concept using a new SDK?

AI excels at:

  • Eliminating repetitive scaffolding
  • Generating conventional patterns quickly
  • Turning abstract ideas into runnable demos

For early-stage validation and exploration, AI is a force multiplier.

2. Exploring and Understanding Codebases

AI is surprisingly strong at:

  • Summarizing unfamiliar modules
  • Tracing data flow across files
  • Explaining complex functions
  • Mapping architectural relationships

As a codebase orientation tool, it reduces cognitive load significantly.

It doesn’t replace understanding — but it accelerates it.

For onboarding, due diligence, or refactoring planning, this is a meaningful advantage.

3. Working Inside Strict Design Systems and Established Patterns

AI performs best under constraint.

If you provide:

  • A well-defined design system
  • Clear architectural boundaries
  • Established naming conventions
  • Folder structure standards
  • Example implementations
  • Linting rules and formatting constraints

AI becomes a high-speed pattern replicator.

It thrives in:

  • Component libraries
  • Internal tooling
  • Enterprise CRUD systems
  • Structured product surfaces

The tighter the guardrails, the better the output.

4. Tasks With Excellent Documentation and Quality Examples

AI is strongest where patterns already exist.

It performs well with:

  • Mature frameworks (React, Vue, Next, etc.)
  • Well-documented cloud SDKs
  • Popular open-source libraries
  • Public APIs with strong example coverage

When documentation is strong and usage is conventional, AI produces high-confidence results.

5. Debugging and Error Interpretation

AI is particularly useful when:

  • Interpreting cryptic stack traces
  • Explaining error messages
  • Identifying common failure patterns
  • Suggesting likely root causes
  • Proposing instrumentation improvements

It accelerates hypothesis generation.

It does not replace careful debugging — but it reduces the time from “something is broken” to “here are plausible causes.”

In complex systems, that acceleration is meaningful.

6. Test Generation and Edge Case Scaffolding

AI is particularly good at:

  • Generating unit test scaffolding
  • Expanding coverage scenarios
  • Identifying edge cases you may not have considered
  • Writing integration test templates

It accelerates the mechanical side of testing — especially when the logic is already clear.

It doesn’t replace thoughtful test design, but it reduces the cost of coverage.

7. Refactoring Suggestions

AI is strong at:

  • Extracting repeated logic
  • Simplifying verbose functions
  • Converting imperative patterns to more declarative ones
  • Proposing clearer naming and structure

When scoped narrowly (“refactor this file” vs “re-architect this system”), it’s effective.

8. Documentation Generation

AI is excellent at:

  • Generating README drafts
  • Writing inline doc comments
  • Producing API usage examples
  • Creating onboarding summaries

This is a low-risk, high-return area for adoption.

9. Converting Between Frameworks

AI is surprisingly useful for:

  • Converting React to Vue
  • Translating JavaScript to TypeScript
  • Moving from REST to GraphQL clients
  • Translating between SDKs

It understands common abstractions and can bridge ecosystems quickly — especially when both sides are well established.

Where AI Struggles

1. Designing Complex Systems From Scratch

AI can assemble components.

It does not:

  • Evaluate multi-year evolution
  • Model organizational constraints
  • Understand internal politics
  • Weigh nuanced tradeoffs
  • Anticipate operational realities

Greenfield architecture requires:

  • Strategic judgment
  • Experience with failure modes
  • Cost modeling
  • Team topology awareness

AI can assist. It cannot own this.

2. Creating Maintainable Architecture

Architecture is about what you don’t build.

It’s about:

  • Clear boundaries
  • Reducing coupling
  • Managing cognitive load
  • Supporting team autonomy
  • Designing for change

AI tends to:

  • Over-generate abstractions
  • Introduce unnecessary layers
  • Optimize locally without system awareness
  • Create patterns that look clean but age poorly

Maintainability requires restraint and long-term thinking.

3. Writing More Code Than Can Be Reasonably Reviewed

AI is happy to generate 1,500 lines instantly.

But velocity is constrained by review capacity.

If you cannot thoroughly review it, you cannot safely ship it.

Unchecked generation increases:

  • Cognitive load
  • Hidden bugs
  • Security risk
  • Architectural drift

Engineering is not generation speed. It is judgment speed.

4. Security Modeling

AI can implement common security patterns.

It struggles with:

  • Threat modeling
  • Subtle injection vectors
  • Complex authentication flows
  • Organizational compliance constraints

Security is contextual and adversarial. That’s difficult for pattern-based generation.

5. Performance Optimization at Scale

AI handles common optimizations well.

It struggles with:

  • Distributed system bottlenecks
  • Memory pressure in production
  • High-concurrency scenarios
  • Cloud infrastructure tuning
  • Real-world telemetry interpretation

Performance tuning requires real-world data and experience.

6. Cross-Team Coordination Decisions

AI cannot:

  • Navigate stakeholder tradeoffs
  • Balance product and engineering priorities
  • Align timelines across teams
  • Mediate organizational tension

Engineering leadership is socio-technical.

AI operates only on the technical side.

7. Product Tradeoff Prioritization

AI does not:

  • Understand revenue impact
  • Model opportunity cost
  • Weigh roadmap sequencing
  • Interpret market signals

Product strategy requires business intuition and domain context.

8. Cost-Aware Infrastructure Design

AI can spin up infrastructure diagrams.

It does not:

  • Optimize for cloud spend over time
  • Anticipate scaling cost curves
  • Understand billing edge cases
  • Balance reliability vs cost tradeoffs

This is where real-world scars matter.

The Real Pattern

AI performs best when:

  • The problem is well defined
  • Patterns are established
  • Documentation is strong
  • Standards are enforced
  • An experienced engineer is supervising

It performs poorly when:

  • The problem is ambiguous
  • Tradeoffs are long-term
  • Organizational dynamics matter
  • Cost, scale, or risk are high

The Practical Takeaway

AI is not replacing engineers.

It is amplifying engineers who:

  • Know what good looks like
  • Can detect architectural risk
  • Can constrain complexity
  • Can review critically
  • Can say “no” to unnecessary code

Used correctly, it increases leverage.

Used without guardrails, it accelerates entropy.

The difference is leadership.