Notes on learning to work with an AI builder
Burly Mingo was never supposed to be a case study.
It started as a simple company site — something lightweight I could stand up between other projects.
Then Kiro entered the picture, and suddenly I had a front-row seat to what real human-AI collaboration looks like — and an excuse to use it. 👍
Figuring out the rhythm
I used ChatGPT for the big-picture work — architecture, planning, and security reviews — and handed the concrete build tasks to Kiro.
Kiro works from a task list, almost like a miniature backlog. It doesn’t just wait for prompts; you give it a sequence of jobs and it moves through them one by one. That part was brilliant. Watching it finish a task, summarize what changed, and queue up the next step felt a lot like working with a fast, disciplined teammate.
Where it stumbled was closure.
Kiro liked to mark a task “done” the moment code compiled. I learned quickly that “done” didn’t mean tested, and “tested” didn’t always mean secure. Once we added verification into each task — run, check, adjust — the workflow smoothed out.
What went right
- Fast, clean prototypes. Once it understood the goal, Kiro could spin up functional pieces in minutes.
- Pattern awareness. It followed conventions once I set them, keeping the codebase organized.
- Task-driven flow. Working from a backlog felt natural and kept the work moving.
- Documentation. Every iteration came with clear notes — the kind of thing most teams forget to write.
What we fixed along the way
- Premature victory laps. I’m guilty of these too. Testing became part of “done.”
- Context drift. When requirements changed mid-conversation, Kiro sometimes lost the thread. Checkpoints solved it.
- Version control. We started by committing straight to main — fast, but messy. Once I called it out, Kiro adapted immediately to a proper branch-and-merge flow. It’s a behavior that should probably be baked in from the start.
- Security. Kiro’s instinct was to make things work, not make them safe. When ChatGPT reviewed the structure, several security gaps surfaced and were corrected. It was a reminder that “functional” and “secure” are not the same thing — and that teams relying solely on AI are going to learn that lesson the hard way.
Those corrections mattered more than any single feature. They taught both of us to slow down just enough to stay correct.
It turns out, Kiro DOES have features built in to handle all of this — I will write up another post after I've tested them out.
The big takeaway
The secret wasn’t magic AI output; it was clarity.
The more specific I was — in specs, validation rules, and workflows — the better Kiro performed.
When the instructions were vague, it filled in the blanks confidently and incorrectly.
Ambiguity wastes time. Clarity compounds progress.
Why it matters
Burly Mingo turned into a proof-of-concept for how small teams (or solo builders) can pair human insight with AI speed.
ChatGPT acted like a senior architect — defining structure and sanity-checking design.
Kiro handled the grind: implementation, iteration, and documentation.
Together they delivered something clean, maintainable, and surprisingly personal.
Lessons worth keeping
- Start from a task list — don’t wing it.
- Treat “done” as tested and reviewed, not just executed.
- Keep your security review human.
- Set up branch discipline on day one.
- Use AI for momentum, not shortcuts.
Closing thoughts
The real takeaway isn’t that AI can build websites.
It’s that, with the right structure, it can join a team and learn from the way you work.
That’s what happened here.
Burly Mingo came out stronger — and so did the process that built it.