How to be fearlessly AI native

Summary of How to be fearlessly AI native

by The Stack Overflow Podcast

40m•August 7, 2026
Listen to Episode

Overview of How to be fearlessly AI native

This episode of the Stack Overflow Podcast focuses on what it really takes to make a software team “AI native” in practice. Host Ryan Donovan speaks with McLaren Stanley, Senior Principal Engineer at Amazon Stores, about how AI changes not just coding speed, but the entire software development lifecycle—from specs and testing to code review, deployment, and team culture. The core message: successful AI adoption is less about generating more code and more about redesigning systems so agents, humans, and automation can work together reliably.

Key Takeaways

  • AI-native engineering is a cultural and operational change, not just a tooling upgrade.

    • Teams need to rethink workflows, ownership, and standards across the SDLC.
    • The biggest gains come when organizations standardize processes instead of adding AI on top of messy existing systems.

  • Code generation is not the main bottleneck.

    • The real constraints are often in testing, validation, code review, and deployment pipelines.
    • If those downstream systems are manual or fragmented, agentic development will only amplify the bottlenecks.

  • AI should move humans “up the stack.”

    • Agents can handle syntax checks, implementation details, and repetitive review tasks.
    • Humans should focus more on architecture, design intent, and whether the team is building the right thing.

  • Specs, tests, and docs are converging.

    • A strong spec becomes the source of truth for implementation and verification.
    • Better requirements lead to better automated tests and fewer human review cycles.

  • Standardization and determinism matter.

    • Centralized libraries, shared deployment patterns, and deterministic design systems reduce agent confusion and improve reliability.
    • The less context an agent has to infer, the fewer mistakes it makes.

How Teams Become AI Native

1. Start with specs and steering

McLaren recommends beginning by having an agent generate steering files, system docs, or initial specs from the current codebase. That gives teams a starting point for understanding what the system actually does—and where tech debt or inconsistencies live.

2. Fix the testing layer

The best AI-native teams invest heavily in testing infrastructure:

  • Property-based testing tied to business requirements
  • Natural-language end-to-end tests that agents can execute across real devices or browsers
  • Robust validation environments so agents can immediately verify whether a change worked

3. Simplify and standardize pipelines

Agentic workflows break down when every team has a different build, deploy, or review process. Amazon’s approach emphasizes:

  • standardized deployment environments
  • fewer runtime and language variations
  • removing unnecessary team-level control over mundane pipeline tasks

4. Use feedback loops to improve the agent itself

Teams should study where agents fail, then feed those lessons back into the steering/context layer. This creates a loop where the system gets better at producing correct code on the first try.

Notable Examples and Insights

The “logging library” problem

McLaren described an early issue where the agent repeatedly generated its own logging libraries from scratch. The fix was to:

  • create a shared logging spec
  • build a centralized logging library
  • instruct the agent not to invent new ones

This illustrates a broader principle: if something is reused, deterministically define it in the system rather than asking the agent to recreate it.

Design systems should be encoded, not inferred

Instead of feeding agents screenshots or prose guidelines and hoping they interpret them correctly, teams should define semantic tokens and structured design-system rules. That makes changes like dark mode or brand color updates much easier and safer.

Regeneration beats manual cleanup

McLaren shared an example where he generated 20,000 lines of code using the wrong Swift version, then discovered the issue later. Because the system was spec-driven, he was able to discard the code, update the spec, and regenerate the project quickly—something that would have taken weeks manually.

Practical Advice for Teams Getting Started

  • Don’t begin by trying to “use AI everywhere.”

    • Start by identifying the biggest bottlenecks in your current process.

  • Make the system explicit.

    • Write down the requirements, design intent, and expected behavior so agents have something reliable to follow.

  • Improve tests before chasing more code output.

    • High-quality validation is what makes AI-generated changes trustworthy.

  • Standardize the boring parts.

    • Pipelines, runtimes, deployment patterns, and approvals should be as uniform as possible.

  • Go slower to go faster.

    • Step back from nonstop feature work and do systems thinking first.
    • Teams that did this saw major gains—McLaren said deployment rates improved by an average of about 4.5x.

  • Be curious and adapt quickly.

    • The AI tooling landscape is changing fast, so teams need to learn continuously rather than treat current practices as fixed.

Final Thought

The episode’s central argument is that “fearlessly AI native” means building an engineering system that can trust, verify, and scale agentic work safely. The winning teams are not simply the ones that generate the most code—they’re the ones that redesign the whole workflow so AI can accelerate high-quality engineering instead of amplifying chaos.