Top AI Trends From 100 Interviews: Inside nWave and the Future of AI-Assisted Development

AI is no longer a future promise for software teams – it’s here, it’s powerful, and it’s already good enough to write large amounts of working code. That doesn’t mean developers are done. It means our job is changing: away from just typing out solutions and toward deeply understanding problems, shaping behavior, and guiding AI systems to build reliable software in small, safe steps.

AI Isn’t Replacing Developers – It’s Changing What Matters

Modern AI can already take a detailed specification and turn it into working code faster and cheaper than most humans. If your main value is simply translating specs into syntax, you’re competing directly with a model – and that’s a losing battle.

What AI cannot do on its own is truly understand the problem space: why the software exists, who it serves, what risks matter, and which trade-offs are acceptable. That work has always been at the heart of good software engineering, and AI makes it even more central.

In this new world, the developer’s core responsibilities shift toward:

• Defining the problem clearly and verifiably

• Providing context, constraints, and priorities

• Making architectural and engineering decisions

• Designing feedback loops and observability

• Iterating in small steps to discover what really works

AI becomes a powerful implementation engine – but humans still decide what to build, why, and how to evolve it safely.

From Coding to Behavioral Engineering

One of the most important ideas emerging from AI-assisted development is behavioral engineering. Instead of thinking only in terms of code and tools, you focus on shaping the behavior of AI systems and software as a whole.

Behavioral engineering includes:

• Describing the problem in a way that can be tested and verified

• Carefully choosing language and constraints for AI prompts and agents

• Defining roles, expectations, and boundaries for each AI agent

• Ensuring the system actually solves a real user problem, not just “works” technically

For example, some models overreact when you use words like “must” or “always” in prompts, especially in all caps. Behavioral engineering means understanding that the model is a mirror of its training data – with all the good and bad that implies – and crafting your instructions to get the behavior you want instead of unpredictable results.

It also keeps humans at the center. Perfectly tested software that nobody uses is still a failure. The goal is not just correctness, but usefulness.

nWave: AI Agents as Real Team Members

nWave is an open-source AI development system that runs on top of Anthropic’s Claude (with work underway to support other models). Its core idea is simple but powerful: treat AI agents like members of your software team, each with a clear role, personality, and responsibility.

Instead of one giant, all-knowing assistant, nWave uses multiple specialized agents, each focused on a specific part of the software lifecycle. At the time of recording, there were 23 agents with more than 90 skills, with more on the way.

Agents With Roles, Personalities, and Boundaries

Each nWave agent is designed using solid software engineering principles, especially single responsibility. Every agent:

• Has a clear role (for example, product owner, architect, tester, or implementer)

• Has a defined personality and behavior profile

• Works within strict input/output contracts

• Operates inside a scoped problem area to reduce hallucinations

There’s also an orchestrator agent that coordinates the others. It’s explicitly constrained to keep its “orchestrator hat” on – it should not suddenly start acting like a coder when its job is to manage the workflow. This orchestration layer can even be fine-tuned to individual users in enterprise setups.

This approach mirrors how you’d structure a real team: clear roles, clear expectations, and limited scope for each person so the whole system stays predictable and manageable.

Opinionated, but Not Rigid

nWave is intentionally opinionated. By default, it nudges you toward practices that are widely considered robust in modern software engineering, such as:

• Hexagonal (ports and adapters) architecture

• Deployment pipelines and continuous delivery

• Double-loop TDD and acceptance test-driven development

• Strong observability and logging from day one

These opinions are built into the agents and their skills, but you’re not locked into a single stack or rigid process. The focus is on principles and fundamentals, not specific tools or frameworks.

If you’re interested in how different AI models play roles like orchestrators and executors in agentic systems, you may also want to check out this guide to top AI models for agent architectures.

Why Small Steps Matter Even More With AI

Because AI can generate huge amounts of code in seconds, it’s tempting to ask for an entire system in one shot. That’s almost always a mistake.

Software development is fundamentally a process of discovery. You rarely understand the full problem up front, and even when you think you do, reality proves you wrong once users touch the system. That’s why iterative development, small releases, and continuous feedback have been best practice for decades – and AI makes them even more critical.

nWave leans into this by structuring work into “waves” of activity, each handled by different agents. The idea is to:

• Specify a small slice of behavior

• Have AI implement and test it

• Deploy or at least run it in a realistic environment

• Observe how it behaves and how users respond

• Refine the specification and repeat

There’s even a product owner agent that can suggest splitting large features into smaller ones – inspired by ideas like “elephant carpaccio,” where you slice big work into very thin, deliverable pieces.

Crucially, this isn’t about big upfront specifications. It’s about fine-grained, iterative specification: describe a bit, build a bit, learn a lot.

Context, Scale, and Taste: Where Humans Still Lead

AI is great at building small, single-user tools or simple apps. Many developers have already used it to quickly spin up personal utilities or prototypes. For that kind of work, “vibe coding” – loosely specifying what you want and letting the AI fill in the rest – can be surprisingly effective.

But professional systems are different. When you’re dealing with money, private data, or global scale, context and taste matter far more:

• Scale changes the problem: A toy Twitter clone is easy; a globally scaled social network with a firehose of data, abuse handling, and reliability requirements is not.

• Most public code is naive: AI models are trained on lots of simple, small projects. Without guidance, they’ll often reproduce naive patterns that don’t hold up under real-world constraints.

• Architecture and trade-offs are subjective: There is no single “right” design. Humans must steer AI toward solutions that fit the domain, team, and risk profile.

In nWave, this human steering happens through how you define and configure agents, how you set constraints, and how you review and refine what the system produces. Your job is to maximize the chance that “the next token” the model predicts aligns with your engineering taste and standards.

Observability is a good example. AI can happily generate code that logs nothing. If you deploy that into production and something goes wrong, you’re stuck digging through opaque, auto-generated code. With the right guidance, though, AI can build in structured logging, metrics, and traces from the start – but only if a human cares enough to ask for it and review the result.

If you’re curious how this broader shift might play out over the next few years, including for small businesses and solo developers, take a look at this overview of AI’s evolution from coding copilot to business superpower.

Working With AI: Continuous Interaction, Not One-Off Prompts

Perhaps the biggest mindset shift is this: using AI effectively is not about writing a single perfect prompt and waiting for magic. It’s about continuous interaction between human and machine.

In practice, that looks like:

• Defining behaviors and constraints for agents up front

• Letting AI propose designs, tests, and implementations

• Reviewing, correcting, and refining its output

• Running small experiments and learning from real usage

• Adjusting agent behavior and specifications as you go

Tools like nWave don’t just help you write code faster. They help you work in a more disciplined, iterative way – and they can even teach you better habits by default, nudging you toward small steps, clear contracts, and solid engineering practices.

AI may automate much of the coding, but it amplifies the importance of what only humans can do: understand problems, design behaviors, and build systems that matter.