TL; DR:
Give agents constraints, not just tasks.
Better output doesn’t mean better methodology.
You’re still responsible for defining done.
No live stream this week -- I am on-call!
My Agents Are Building. Am I Giving Them What They Need?
I’ve been building a creature-breeding game called Evo Habitat Zero with AI agents. One works on the game mechanics. Another works on art and assets. And honestly? It’s been pretty cool watching a game come together this way.
It’s also been rocky.
There have been moments where I look at what happened and think, “Holy crap. How did we get down this path?” Builds were crashing. Simple assets were enormous. The art was improving, but getting there could take a lot of iteration. And the mechanics agent seemed to think it was finishing a game that I definitely wouldn’t call done.
The interesting part isn’t just that agents made mistakes. Some of those mistakes pointed directly at guidance I hadn’t given them.
So I want to walk through what’s been working, what hasn’t, and what I’d encourage you to look at in your own workflow.
You can check out my full thoughts on this in the video below:
Don’t Turn Your Workflow Into a Tool Popularity Contest
I’ve been balancing GitHub Copilot CLI and Claude Code. I’ve used Copilot CLI much more heavily this year, so the way I develop things is better aligned with that workflow.
That matters when I decide where to put my attention and usage budget.
For BrandGhost, which has paying users, I’ve been leaning on the workflow I’m most familiar with: Copilot CLI. I’ve been using Claude Code for the game, where I have more room to experiment.
Does that mean I think Claude Code is inferior?
No. Familiarity with a workflow isn’t proof that one tool is universally better. Both have pros and cons. I’m making a choice based on the work, my experience with the tools, and how I’m allocating my budget. I’ve said this for years about picking the right time to learn vs ship value, and I will happily focus on learning new things for games on the side while using the things I know best for shipping value.
The same underlying point applies when we talk about engineering judgment after AI changes our language choices: generating more of the implementation doesn’t make those choices disappear.
Actionable Tip: Pick a workflow you can evaluate, not just a tool people are excited about. For a critical project, ask yourself how confidently you can review the result and catch a problem.
I Forgot to Define What an Acceptable Asset Looks Like
One of the biggest hurdles with the game was that my builds kept crashing.
I found a couple of things going on. I wasn’t using a Unity asset cache, and my builds were spending around 40 minutes importing assets. I also had builds running in parallel on nodes that couldn’t manage it, and a shared mutex meant they’d eventually bottleneck causing enormous delays.
Then there were the assets themselves.
The art agent had produced some fairly simple models with files around half a gigabyte. Not half a gigabyte of memory. Half a gigabyte on disk for a simple model.
This isn’t an art-intensive game. That wasn’t a reasonable result for what I was trying to build. And loading those assets during editor builds was part of the mess I was investigating.
But here’s the question I had to ask myself: had I actually told the agent what an acceptable asset size was?
It had been making models and textures. It didn’t have the constraints I needed it to work within. And I never told it -- so that’s actually on me.
I could keep asking for more assets and deal with the consequences afterward. Or I could stop and define the boundaries. The first option lets the work keep moving, but I was already seeing the cost of that approach.
Actionable Tip: Before sending an agent off to generate a batch of assets, define what you’ll accept. Think about file size, texture dimensions, visual complexity, and the target you’re building for. Don’t borrow arbitrary limits from someone else’s project; choose limits you can justify for yours.
Iterating on the Output Isn’t the Same as Improving the Process
The art agent has been sending me screenshots every few hours, and I can see the improvements.
Models get better shapes. Textures stop looking like pictures stretched across awkward surfaces. Sometimes an iteration looks worse, and a later one looks noticeably better.
That’s progress.
But I wasn’t seeing the same improvement in how the agent approached the work. It would get something to a “good enough for now” state, land it, and come back for another pass.
If a relatively simple asset takes a couple of weeks of that cycle, I want to understand why. Is the agent using feedback to change its method, or just trying another version?
I’m not claiming agents can’t retain lessons or improve their workflows. I’m describing what I was observing in this setup. Better screenshots alone didn’t tell me the methodology was getting better -- and that’s exactly what I am going to need to happen if I ever expect this to approach completion!
That distinction is why I keep coming back to fixing the feedback loop instead of repeating the same request.
Actionable Tip: When a result improves, ask what changed in the approach. If there’s a useful lesson, capture it in the workflow. Don’t assume a better artifact means the next task will start from a better method.
“Make It Better” Wasn’t Enough Feedback
The game has a space station with metallic surfaces, but the creature habitats are organic. I need those styles to work together.
Moss was a good example of where things got awkward. The placement looked cool. The texture looked like a photograph stretched over a funny surface. And to be fair, I probably couldn’t do it better myself.
So I took screenshots into ChatGPT and explained what I thought was working and what wasn’t. I asked it to turn that criticism into generalized guidance for the art workflow. I also asked it to remake the screenshots with the improvements, so I had a visual reference.
Then I gave the guidance and reference back to Claude Code, asked it to update its instructions, and gave it a targeted fix.
The first result still wasn’t what I wanted. But after more iteration, I had screenshots where the moss looked pretty good.
There are tradeoffs here. A written description is easier to reuse across different assets, but it can leave a lot open to interpretation. A visual reference makes the target more concrete, but I still have to judge whether it actually fits the game.
Neither replaces reviewing the result.
I’ve talked before about AI-built game art needing human judgment, and this experience keeps reinforcing that point.
Actionable Tip: Give feedback in three parts: what to preserve, what to change, and what an acceptable result looks like. If the problem is visual, a reference may communicate something that another paragraph of “make it look nicer” won’t.
The Agent’s Task List Isn’t My Definition of Done
The mechanics agent was reaching a point where it seemed to think the game was finished. It was finding extra little things to do.
I could tell the game wasn’t done.
My next move is to pause it, play through what exists, and use that experience to lay out a new roadmap. More activity isn’t going to answer the question I actually care about: do I have the playable experience I want?
I have another role-playing game idea with an action format and a turn-based companion experience. I love building itemization systems, and I’ve already built a lot of that kind of stuff.
But having those systems isn’t the same as having something playable.
That’s why I want to start with the turn-based experience and set better constraints, rather than try to tackle the bigger action-game scope all at once. Smaller scope gives me something more concrete to evaluate. It also means deliberately leaving some of the exciting ideas for later.
And while it doesn’t seem like it, there’s some engineering logic here: Break big problems down into manageable parts. I am trying to solve the big challenge of putting together a role playing game, but I cannot do so all at once -- and this is my attempt at splitting it into smaller pieces to make progress.
Whether you’re building a game or an application, you still own the quality of AI-written work.
Actionable Tip: Write down the experience that needs to work before adding more tasks. Walk through it yourself. If it falls short, give the agent the observed gap, not just another feature to keep it occupied.
My Weak Spots Show Up in the Guidance
One thing that has worked well across my projects is reusable instructions. I’ve been taking lessons from different kinds of work and bringing them into other projects.
For a cross-platform app prototype, I had several templates available. We could compare the technology choices, talk about the pros and cons, and scaffold the app quickly.
The UI still didn’t look good. The art didn’t look great either.
And that’s the irony I keep running into. I feel comfortable architecting systems and building software, and I’ve been able to give agents useful guidance in those areas. I don’t have the same experience producing great-looking UIs or game assets.
Those are also the areas where my guidance has been weakest.
I’m not saying every agent failure is your fault. I’m saying that in my own work, my lack of expertise hasn’t magically disappeared because I delegated the implementation.
Turning a lesson into a reusable workflow with a visible result gives me something I can carry forward. But I still need to check that the lesson is useful and that the result meets the goal.
So that’s what I’m trying to improve: better constraints, more specific feedback, and a clearer definition of done.
Not just more agents doing more things.
Join me and other software engineers in the private Discord community!
Remember to check out my courses, including this awesome discounted bundle for C# developers:
As always, thanks so much for your support! I hope you enjoyed this issue, and I’ll see you next week.
Nick “Dev Leader” Cosentino
social@devleader.ca
Socials:
– Blog
– Dev Leader YouTube
– Follow on LinkedIn
– Dev Leader Instagram
P.S. If you enjoyed this newsletter, consider sharing it with your fellow developers!



