Welcome back to my journey of discovering AI tools that probably everyone else has been using for months. If you missed Part 1, I talked about GitHub Copilot’s custom instructions – a small but mighty feature that makes your AI autocomplete actually useful.
Today, I want to talk about something that feels almost like magic (no worry, there is a reality check at the end of this post 😉): autonomous AI agents that write code for you. Not just autocomplete. Not just suggestions. Full features. Entire applications. Bug fixes. While you grab coffee.
The AI Tooling Chapter
Before I dive in, I need to give a massive shoutout to the “AI Tooling Chapter” at work. This is a bunch of super talented, friendly, and motivated people with a thing for AI, AI-assisted coding, RAGs, and more. I’ve learned a lot from them in the past, and I’m sure I’ll learn even more in the future. If you’re lucky enough to work somewhere with a community like this, lean into it. These folks are the reason I’m not completely lost.
From Copilot to Autonomous Agents
GitHub Copilot in the IDE is great. It autocompletes my code, suggests patterns, and occasionally saves me from having to Google “how to reverse a string in Javascript” for the thousandth time. But it’s reactive. It waits for me to start typing.
What if you could just describe what you want and let an AI agent handle the rest?
That’s where tools like OpenCode come in.
What is OpenCode?
OpenCode is an open-source AI coding agent that lives in your terminal. Think of it as a junior developer who never gets tired, never complains about legacy code, and works with whatever AI model you’re already paying for – Claude, GPT, Gemini, GitHub Copilot, you name it.
A colleague recommended it to me a while back in the “AI Tooling Chapter”, and after finally getting around to trying it, I’m impressed.
Here’s what you can do with it:
- Fix bugs by describing the problem in plain English
- Add entire features to an existing codebase
- Generate complete applications from scratch
- Whatever you can
think ofprompt…
And unlike some proprietary tools, OpenCode doesn’t lock you into a specific AI provider. Already have a ChatGPT subscription? Use it. Prefer Claude? Go for it. Want to run local models? That works too.
Plan Mode vs. Build Mode
One of the smartest things about OpenCode is how it separates thinking from doing. And to give some context here as well: Other tools have a similar way of separating “plan” and “build”, but the implementation in OpenCode is the best one I’ve seen so far.
Plan Mode
When you ask OpenCode to do something, it first enters plan mode. This is where the AI:
- Analyzes your request
- Explores your codebase to understand the context
- Creates a detailed implementation plan
- Shows you exactly what it’s going to change before touching any files
This is brilliant. You get to review the approach, catch potential issues, and make sure the AI actually understands what you want. It’s like having a junior dev write up their implementation plan before starting to code – except this one actually does it consistently.
Build Mode
Once you approve the plan, OpenCode switches to build mode and executes the changes. It writes code, modifies files, and can even start a build and run the tests to verify everything works.
Why start with plan mode? Because AI is smart, but not psychic. Sometimes it misunderstands your requirements. Sometimes there’s a better approach. Sometimes it’s about to refactor half your codebase when you just wanted a one-line fix. Plan mode gives you a safety net.
Not the Only Game in Town
OpenCode isn’t the only tool doing this. There are several others worth checking out:
- Goose – Another open-source coding agent
- Aider – A popular choice with similar capabilities
- and more…
All of these tools let you bring your own AI provider, which means you’re not locked into a specific ecosystem.
That said, I like OpenCode. The plan/build function feels right, and the fact that it’s open-source with a massive community (80,000+ GitHub stars) gives me confidence it’ll stick around for a while.
What This Means for Busy Engineers
If you’re like me – spending more time in meetings than your IDE – these autonomous agents are awesome. You don’t need hours of uninterrupted flow state to make progress on that side project or fix that annoying bug.
You can:
- Describe what you need in a few sentences
- Review the plan (maybe during your next Zoom call with your camera off – I won’t tell)
- Let the agent implement it
- Review the code and iterate if needed
It’s not perfect. You still need to understand what the code does. You still need to review changes carefully. But it dramatically lowers the activation energy for getting things done.
The Reality Check
Now, before you think I’ve gone full AI evangelist, let me pump the brakes a bit.
While I’m pretty happy – maybe even enthusiastic – about these tools, I’m fully aware that we will not (or at least should not) let Copilot, Claude, Cursor, Windsurf, or any other AI write all our new features by itself.
Sure, it feels magic at first. But AI is only as good as its input. And let’s be clear: most input isn’t good enough to just magically work perfectly. “Garbage in, garbage out” still applies to AI. Or especially to AI.
We need to be mindful about where and how we use these tools.
That said, for my use cases, it’s worked pretty well so far. And yes, I’m mostly working on side projects or smaller helper apps these days. So it doesn’t really matter if my code runs 0.1 seconds or 5 seconds. There is no PII (personally identifiable information) being processed by the tools I write. And if there’s a bug, I won’t put our company financials at risk. I’m sure you already got what I’m going for: In all of these (and many more) scenarios, you might want to be extra cautious with code generated by AI.
Small applications with easy-to-understand project structures and clear, well-separated components. That’s where AI can shine. Give it a messy monolith with tangled dependencies and vague requirements, and you’ll spend more time fixing what the AI broke than if you’d written it yourself. Give it a clean architecture and a specific, well-defined task, and it can be remarkably effective.
Closing Thoughts
I’m still learning. I’m still late to this party. But tools like OpenCode are making me feel like I’m not that far behind. I’ve used it to generate features for some custom tools I use on a regular basis and I’m very confident that it has not turned it an unmaintainable “big ball of mud”. But I’m also sure I only saw the tip of the iceberg so far and tools like OpenCode, Claude or Cursor can do much more.
My recommendation: Next time you have a feature to build or a bug to fix (and you are not working in one of those super sensitive domains I mentioned), consider letting an AI agent take the first pass. You might be surprised at how much time you save – and how much you learn by reviewing what it produces.
Just don’t forget: you’re still responsible for what ships. AI is a powerful assistant, not a replacement for thinking.