I spent the last week playing around with GitHub Copilot and vibe coding a couple of apps and tools. While I’ve been using GitHub Copilot for hobby projects since 2023, I’m not writing code in my day job anymore.

It was great to see how far the tools have come. I’ve used the early versions of agent mode, and I’ve been going back every now and then to test some things; but this week I invested a bit more time in vibe coding.

And it’s been amazing. Let me share 3 lessons learned:

Your SDLC process matters a lot

I accidentally broke my production website, and was lucky to have systems in place to quickly roll back. Let me explain:

At one point this past week, I had three different versions of my running-blog sitting in different PRs on GitHub. Each made changes to different tools I’d been developing. When I initially created my running blog, I had never thought about having more than 1 PR, just for the blog post I was working on then.

However, that changed this week, and I had an instance where I made a configuration mistake on one branch, accidentally pushed that to the production website and the website was no longer functional. Lucky for me, I had automation setup with GitHub Actions to do a rollback to a working site and didn’t have to do crazy stuff to get it working again.

My point in telling this story is that the way your entire software development lifecycle process is set up matters a lot. These agents can create massive amounts of code. That code needs to be reviewed (vibe coded code might not need to be reviewed; but if you plan on working on a production enterprise system, I think it still needs to), it needs to be tested, and ideally be put in production in a safe way.

If you have systems already set up for testing and automation, you’ll be able to benefit more from the agentic code wave than if you don’t have these set up. Software development is not just about writing code; it’s about integrating it into a larger system in a safe and repeatable way.

The tools have improved a lot

A combination of LLM improvements (codex 5.2 and opus 4.5 in particular) have made the outcome of the agents drastically better. I’ve been playing around with some ideas for a year, and I felt like these LLMs were the first ones that really got where I was going; and were able to build what I needed them to build.

But we’ve not just seen improvements in LLMs, we’ve also seen improvements in how the tools themselves have evolved. This past week I’ve used:

• GitHub Copilot agent mode in Visual Studio Code. The tried-and-true agentic developer.
• GitHub Copilot CLI. Gamechanger! It’s so fun to do vibe coding in the terminal. I think I spent 70% of my past week in the CLI making changes to my apps.
• Claude, Codex and Copilot in github.com as background agents. Super useful, primarily for small background tasks.

If you haven’t yet tried out developing in a CLI (either GitHub Copilot, claude code or Codex) I recommend you try it out. It’s a very refreshing interface that has a couple of benefits. First, you can have multiple CLIs open in parallel working on different branches. Second, it focuses your thoughts on the conversation and the spec, less on files and lines of code.

Having said that, I believe we’re not going to end up in a world where all development will be done in a CLI. I think the right combination of IDE, CLI and background agents is going to be where we end up. Each of those tools has a sweet spot use case, and I believe all three will remain relevant.

• IDEs will remain the place where precise work on code will happen. They remain where you work with the agent to change code, make your own changes, and run/test/debug your code.
• CLIs will be where you can start coding. They can be the fast iterative development cycle. Very lightweight, highly parallel experimentation.
• Background agents will be used heavily for async background tasks. I’ve mainly used them now for small use cases, but I can see them potentially do larger routine tasks as well, like for instance upgrading frameworks.

Instructions matter

I’m not an expert yet, but I have noticed that instructions matter a lot for the AI agents. Instructions can be about the project and best practices; but they can also give the agents nudges on how to be more useful.

One such nudge is something I borrowed after listening to the OpenClaw founder interview on pragmatic engineer. He mentioned giving his agents the instruction to take a screenshot of the UI after making UI changes. That’s a brilliant use case for a custom instruction, and something I’ve used in my agents this week.

Ideally, I think I would have instructed them to use a UI framework like Playwright, and maybe that’s what I’ll test next week.

Back to custom instructions: There are a few ways to give them:

1. Custom-instruction files: These can either be custom-instructions.md or agents.md (interchangeable). You can define these custom instructions either on a user level, repo level or at an org level; or at multiple levels at the same time. Important to know is these apply to all tasks an agent would execute by default, unless you specify in the instructions files that they only apply to certain paths.
2. Prompt files: Prompt files define reusable prompts for certain tasks that you, or members of your team, would execute multiple times. Prompt files are mainly task focused. Think about providing a prompt to an agent to create unit tests with specific details about your environment. This wouldn’t go in your custom instructions, because those would apply to all the code generation.
3. Custom agents: Custom agents apply to an entire session of GitHub Copilot agent mode. They would change the behavior of the chat to have the agent take on a certain persona; like the persona of a tester. You can then iterate with that custom agent.

While I admit I’m not an expert when it comes to all these config files, it was clear to me that by even providing some automatically generated instructions, the agents worked way better than they did out of the box.

Conclusion

Agentic coding is having a huge impact on the software industry right now. While my lessons learned this week were 100% in the vibe-coding camp, I do hope you took away:

1. You need a mature SDLC process to get the most benefits out of agentic coding.
2. The interface (IDE/CLI/background) matters, and why all three will remain relevant.
3. You need to learn how to build guardrails around the agents to have them work best for you.

AI is getting good at writing functioning code, we now need to learn how to integrate that into engineering processes.