AI is my new code buddy
AI collaboration works best with structured workflows. What if you could ask it to build systems, not just code? Read: "Everything Starts Out Looking Like a Toy" #258
Hi, I’m Greg 👋! I write weekly product essays, including system “handshakes”, the expectations for workflow, and the jobs to be done for data. What is Data Operations? was the first post in the series.
This week’s toy: You might listen to podcasts at 1.25x or 1.5x to speed up comprehension when the speaker is slow. Have you considered using the same technique when you are processing audio with ChatGPT? It turns out it works! Speeding up the processing of audio output when you are transcribing also saves you money on tokens.
Edition 258 of this newsletter is here - it’s July 7, 2025.
Thanks for reading! Let me know if there’s a topic you’d like me to cover.
The Big Idea
A short long-form essay about data things
⚙️ AI is my new code buddy
Ideas vs execution gap
I have lots of ideas that I'd like to build. Some of these are easy to build (ask a friendly LLM!) and others are a bit more complicated. Once you go beyond the typical context window of a chatbot, you have to think of a new way to build applications. And also, you might not want to tend the work of a Chatbot to build apps.
Sound familiar? You're not alone. Developers with a solid idea of what to build and how to build it can use LLMs to build almost anything, but the real question is: how do you do it well?
The answer is the same way you'd work with another developer.
You write user stories, create manageable chunks of work, ask for progress updates, and iterate. A proper development workflow helps AI maintain context and avoid hallucinating. When you build, using a CLI with deterministic inputs and outputs keeps LLMs on track and focused on the actual problem.
More importantly, you try to scope your work so that you can fit it neatly into a branch on Github. Scope creep happens when you stop focusing on the current work and drift into another related task (so tempting).
So what would happen if we came up with a structured development workflow to "teach" an AI and keep the context updated? When the AI picks up new work, it has a placeholder to keep it anchored. Your AI intern just got smarter, and a lot more effective.
Treating AI as a teammate
My first experiments with AI in development were predictably basic. I'd ask ChatGPT to help debug some code or explain a concept. It was useful, but it felt limited to answering a question like "how do you format a concatenation function in Snowflake?" or "how do you write a Google Sheets formula to extract the domain from an email."
In 2025, these tools are capable of complete app development. Yeah, I know, this is not a surprise to you if you've been paying attention. The difference comes when you move from a single page app to something much more complicated.
There is a big difference between "build me a game" or "build me a website" or "build me an app" and in writing the specific rules you need to make that experience feel like a good one. Fortunately, AI systems are pretty good at following rules and structure if you provide it to them.
A structured development workflow
The basic idea here is to create a workflow that both an AI and a human dev can follow, so that we both follow better development practice.
My insight was to behave like any other development process:
write stories
build tickets that represent the work to be done
for each ticket or group of tickets, build a branch that represents that work
during each development session, start by updating an agent context (a markdown file for the agent to review when looking for work)
at the end of each development session, have another command to wrap up
Asking Cursor to build me a CLI was an easy way to do this. With the functions I was supposed to do at each point, it became much more of a conversation with the bot to tell it where we were and what we were doing in the coding exercise.
After I did this a few times, I abstracted it into an open source repository (https://github.com/gregmeyer/build-your-app-w-cm-kit) that other people could try if they wanted.
The 15-command workflow
The CM Kit centers around 15 CLI commands that create a structured development environment:
Session Management:
session-start - Begin a development session with context validation
session-wrapup - Complete a session with documentation and cleanup
Project Tracking:
list-tickets - View available development tasks
pick-ticket - Select and start working on a specific task
update-ticket - Update task status and add notes
status-report - Generate comprehensive project status
sprint-report - Create sprint-level progress reports
Quality Assurance:
validate-structure - Check project organization
validate-docs - Ensure documentation is complete
check-deps - Verify dependencies and security
qa-test - Run comprehensive quality checks
test - Execute test suites
Project Management:
list-stories - View user stories and requirements
list-issues - Track bugs and problems
pick-story - Select a story to implement
archive-project - Create timestamped backups
How to use this system
Here's how I use this workflow to run development sessions.
Session Start: I run session-start which validates my project structure, loads the current context, and primes the AI with the right information.
Task Selection: I use list-tickets to see what needs to be done, then pick-ticket to focus on one specific task.
Collaborative Development: I work with the AI, explaining the problem, exploring solutions, and iterating on the implementation.
Quality Checks: I use validate-docs and qa-test to ensure everything meets standards.
Session Wrapup: I run session-wrapup which documents what we accomplished and prepares for the next session.
This structured approach eliminates the chaos that often comes with AI collaboration. Instead of random conversations, we have focused development sessions with clear goals and outcomes.
So, does it work?
Ok, vibe coding isn't perfect. But this system works! I revised my website in a weekend and built a prototype for a new website in 7 days—projects that would have taken weeks or months with traditional development approaches. But the real insights aren't just about speed—they're about quality and consistency.
Productivity improvements
Development Speed: Significantly faster feature development through focused collaboration
Bug Reduction: Fewer bugs in production due to systematic quality checks
Documentation: Complete documentation for every feature as part of the development process
Code Quality: Consistent style and patterns across all projects
The collaboration patterns that work
Through trial and error, I've identified specific patterns that make AI collaboration effective:
Context-First Development - Instead of starting with code, I start with context. I create a markdown file that explains the problem, the desired outcome, and any constraints. This gives the AI the same context I have, leading to better solutions.
Iterative Refinement - I treat each development session as a conversation, not a transaction. We start with a rough approach, test it, refine it, and improve it. The AI helps me think through edge cases and alternative approaches.
Quality Gates - Every piece of code goes through automated quality checks. The AI helps me write tests, validate assumptions, and ensure the code meets our standards.
Documentation as Code - Documentation isn't an afterthought—it's part of the development process. The AI helps me write clear, comprehensive documentation that actually gets used.
Why did I build the CM Kit?
The CM Kit itself is a perfect example of this process in action.
I started with a simple idea: "I need a way to manage development sessions with AI."
Instead of building it all at once, I broke it into small, manageable tickets. Each session focused on one specific feature. The AI helped me think through the architecture, identify potential issues, and implement the solution.
The result? A comprehensive development workflow system that I can use for any project, built in about 40 hours of focused development time. Without this collaborative approach, it would have taken months and probably never gotten finished.
The CM Kit is a toy, and I’m hoping someone will develop something useful on it. But it also doesn’t matter if it turns out to be nothing more than an experiment.
The future of software development
Approaches like this one are not just about making individual developers more productive. They are intended to change how we think about software development.
This creates new opportunities for:
Indie hackers who can now build MVPs in weeks instead of months
Product managers who can prototype their ideas without waiting for engineering resources
Domain experts who can build tools for their specific industries
Small teams who can compete with larger organizations
The bottom line
AI collaboration isn't about replacing developers (yet).
It's about amplifying their capabilities. When done right, it creates a development environment where:
Ideas get built faster
Quality is consistently high
Documentation is always current
Innovation happens more frequently
The CM Kit is my attempt to systematize this approach, but the real value isn't in the specific tools.
Want to try this approach? I've open-sourced the CM Kit workflow system at github.com/gregmeyer/build-your-app-w-cm-kit. It's designed to work with any AI coding assistant and can be adapted to your specific workflow.
If you're sitting on ideas that you can't get built, or if you're frustrated with the pace of traditional development, this approach might be worth exploring.
Start small, focus on structure, and treat AI like a teammate rather than a tool.
What’s the takeaway? The future of software development isn't about choosing between human developers and AI—it's about learning to work together effectively. And for solo builders and small teams, that future is already here.
Links for Reading and Sharing
These are links that caught my 👀
1/ The statistically improbably restaurant - I love this post about the prevalence of certain food types in the median American city by Ethan Zuckerman. If you’ve ever wondered, “how many Thai restaurants are there in Seattle as a percentage of all restaurants?” this post is for you.
2/ Mr. Miyagi was right - It turns out the boring repetition is the key for finding Flow, or the state of heightened awareness we reach when things become automatic. This lends credence to “practice every day.”
3/ How big are LLM models now? - In case you’re wondering …
What to do next
Hit reply if you’ve got links to share, data stories, or want to say hello.
The next big thing always starts out being dismissed as a “toy.” - Chris Dixon