Intent-Driven Engineering – Instructor Narrative

Intent-Driven Engineering – Instructor Narrative

Alright everyone, let’s take a step back for just a moment before we jump into the demo.

What we’re really talking about today is not just another tool.

What we’re talking about is a shift in how software engineering actually happens.

For a long time — decades really — the core activity of a developer was very straightforward.

We wrote code.

Line by line, file by file, service by service. That was the job.

Then frameworks came along.

Spring Boot. React. Scaffolding tools. Code generators.

Those tools helped us write code faster, but we were still fundamentally doing the same thing.

We were still hand assembling systems.

Now something different is happening.

With AI-assisted development — tools like Claude Code and others — we’re starting to move toward something new.

We’re starting to move toward intent-driven engineering.

Instead of telling the computer how to build something line by line, we start telling the system what we want to exist.

That’s a very different mindset.

Understanding Where We Are Today

If you look at how a lot of teams are using AI tools right now, the workflow often looks something like this.

You open an AI tool.

You write a prompt.

You copy the response.

You paste it into your editor.

You adjust some things.

You go back and prompt again.

And eventually, after a few iterations, you get something that works.

Now there’s nothing wrong with that. In fact, it’s incredibly powerful.

But it’s also a little chaotic.

There’s not always structure.

There’s not always governance.

And there’s not always a repeatable process.

What intent-driven development tries to do is bring structure to that interaction.

Instead of constantly prompting tools in an ad-hoc way, we define intent once, in a structured way.

That intent becomes the source of truth for the system we want to build.

Learning the Mechanics

Now before we can build full systems this way, we have to learn the mechanics.

Think of this like flight simulator training for engineers.

Pilots don’t start by flying a passenger jet across the Atlantic.

They start in a simulator.

In the same way, we start by learning the fundamentals:

How to write intent files.

How to structure instructions for Claude Code.

How to use the governance layer — the claude.md file.

And how the AI interprets those instructions to generate artifacts.

At this stage, we’re not focused on building massive systems.

We’re focused on learning how to communicate engineering intent to AI systems effectively.

Moving From Code to Systems

Once those fundamentals are understood, something interesting starts to happen.

Instead of thinking about individual files and classes, we start thinking about systems.

For example, instead of saying:

“Write me a React component.”

We might say something like:

Build a React frontend with a Node.js TypeScript backend that exposes a REST API and returns data to the UI.

That single statement describes an entire system architecture.

And tools like Claude Code can take that intent and generate:

• The frontend application

• The backend service

• The API endpoints

• The project structure

• The build configuration

All the pieces needed to make that system runnable.

At that point, the developer is no longer just writing code.

The developer is directing the system.

The Live Demo

So now we move from theory into practice.

In this demo, we’re going to build a small system together.

Not just code.

An actual working system.

We’re going to create a simple application — a dice roller.

The frontend will be built in React.

The backend will be a Node.js TypeScript REST API.

The frontend will call the backend.

And the result will appear directly in the browser.

What’s important here is not the complexity of the example.

What’s important is the process.

We’re going to describe what we want the system to be…

…and then let the system generate the implementation.

The New Role of Engineers

Now here’s the part that I think is the most interesting.

When you start working this way, the role of the developer begins to evolve.

Developers spend less time writing syntax.

And more time focusing on things like:

Architecture.

System boundaries.

Intent definition.

Validation.

Integration.

In other words, the developer becomes less of a code typist and more of a system architect and director.

The AI helps assemble the pieces.

But the engineer still defines the vision and the design.

Final Message

So if there’s one thing I’d like you to take away from today, it’s this.

What we’re doing here is not just speeding up coding.

We’re changing the way systems are built.

And when we run this demo and see the application come up in the browser, that moment is important.

Because it shows something very clearly.

We didn’t just generate a few files.

We didn’t just generate a function.

We generated a working system.

And that’s where the real power of intent-driven engineering begins.

Final 30-Second Closing

Let me leave you with one final thought.

For most of the history of software engineering, developers spent their time telling computers exactly how to do things.

Line by line.

Method by method.

File by file.

But the future of engineering may look a little different.

Instead of focusing on syntax, engineers will focus on intent.

Instead of assembling every piece manually, we’ll guide intelligent systems to build what we envision.

And the developers who thrive in this new era won’t be the ones who type the fastest.

They’ll be the ones who can design the clearest systems and express the strongest intent.

Because the real shift happening in engineering right now is simple.

We’re moving from writing code…

to creating systems.