I ran a workshop yesterday on agentic engineering.

It really just comes down to this: how do you get more value out of AI?

The moment that clicked

I walked through a case study from my recent personal experience.

I had a project I estimated at around 40–50 days.

I got about two-thirds of it done in two days.

That’s not a small improvement. That’s a different way of working.

And it wasn’t just “using AI.”

The difference

If you treat AI like something you just prompt, it works for a bit. Then it plateaus.

  • It forgets everything
  • It tries random approaches
  • It gives you code that might work but isn’t right

Instead of just trying a different prompt or fixing the code yourself each time, the shift is:

Stop thinking in prompts. Start thinking in skills.

Give the agent something to stand on

AI doesn’t have memory.

So you have to give it memory.

That’s what skills are.

They capture things like:

  • how your API is structured
  • how you build UI
  • how you test
  • how you debug
  • how you interact with tools like Jira or the browser

Instead of re-explaining everything every time, you just reference the skill.

Now the agent is working from your patterns, not guessing.

Build the skills as you go

This is probably the most important habit.

If you’re doing something more than once, it should probably be a skill.

Simple example: I needed to build a custom field in a forms module. So I built it. But I also created a skill that explains how to build fields like that.

Now:

  • the next time is faster
  • other people don’t have to figure it out
  • the agent doesn’t thrash

You’re not just doing the work. You’re setting up the next piece of work.

Watch where the agent struggles

This one is easy to miss at first.

If the agent is:

  • trying different ways to use git
  • fumbling around connecting to the database
  • struggling to debug
  • generally spinning

That’s not just friction. That’s a signal.

You’re missing a skill.

Fix it once. Capture it. Now nobody has to go through that again.

When the code is bad

This happens all the time.

The agent generates code and it’s… off. Wrong patterns. Weird structure. Code smell. Doesn’t match how you build things.

Instead of just rewriting it or patching it locally, the better move is:

Fix the skill, not just the code.

Once you fix that, the next output is usually better. And the one after that.

What actually changes

Once you start working like this:

  • You’re not starting from zero every time
  • The agent behaves more like your team
  • Work becomes more predictable
  • Throughput goes way up

But the bigger shift is this:

You’re not just using AI. You’re building a system around it.

If you do one thing

Don’t overthink it.

Pick one thing you do more than once. Turn it into a skill. Use it the next time.

That’s it.

Final thought

When the AI runs again, it’s better.

Because we organized and improved its memory while it was inactive.

Humans are basically the sleep cycle for AI. We sort what worked, fix what didn’t, and shape the next run.

You’ve probably felt this before. You go to bed stuck on something. You sleep on it. You wake up, and it’s clearer.

Same idea.

If you want the fuller playbook, see Agentic Engineering: Practical Guide.