The ‘Vibe Coder’ Badge

Around November last year (specifically 14th November 2025), I decided to spend my afternoon in the Students’ Centre at school coding. It was a class activity for my Mobile Application Development course where I was to build a mock of a social media platform of my choice (I chose Instagram).

I’m not one to do schoolwork on a Friday afternoon, especially when I’m still on campus 😂, but on this day, all my friends were still in school trying to complete the same exercise, so the productivity gods were aligned 🙏🏽😭.

Everything was going well until it didn’t. I asked the Gemini extension in Android Studio to add a feature to my app, and from then on, the errors wouldn't clear. And I know we can all relate to that moment when your code is perfectly fine, and you add one small thing… and suddenly the entire system acts as if it has never seen logic before 😭. I tried debugging the code again using Gemini, but the errors kept piling up.

That’s when I finally got the courage to ask one of my friends for help (which I rarely do). He spent a couple of minutes trying to debug it, and he too couldn’t figure it out! At this point, I’m getting flustered cause it was enough asking for help, but for someone not to figure out my problem must count as double embarrassment 😭

My laptop was passed to another guy, who tried rebuilding the project and doing a clean build. And there it was. You know those Russian nesting dolls? The ones where, when you open the outer shell, it reveals a similar but tinnier version inside of it? That’s EXACTLY what happened with my project. Four duplicates of the same project interlaced into each other like the Russian dolls 😭. Of course, I was puzzled, and I remember laughing it off because I honestly could not even explain to the people around me how this happened.

“You’re a vibe coder, right?” went the guy whom I first reached out for help with my errors. At the time, I didn’t know what that meant, so I laughed it off, AGAIN (at this point, I think you’re sensing a pattern of me laughing in awkward situations 😂😂) and I said, “I guess. I don’t know”. In my head, a vibe coder was someone who codes with music in the background, probably building a cute passion project, coding for vibes and aesthetic 😭. I also wasn’t sure whether this ‘label’ was an insult or some sort of flattery, but at that moment, it sure felt like a diagnosis.

So, What Exactly is Vibe Coding?

After a bit more research and exposure to the term, I finally got clarity.

Vibe coding isn’t just “coding with good vibes” 🤣🤣

It’s when you rely on AI tools to generate or modify your code without deeply understanding what’s happening underneath. You prompt. You accept. You move on.

Until something breaks.

And when it breaks… you don’t actually know why.

That November afternoon? That was me.

I had asked Gemini to add a feature without fully thinking through my architecture, dependencies, or build process. When things went wrong, I kept prompting instead of stepping back.

I wasn’t coding with intention.
I was coding with momentum.

The Masterclass: What Shifted for Me

I attended a vibe coding masterclass recently that didn’t shame vibe coding. It reframed it.

Here are some takeaways from the session that shaped my perspective change:

a) Planning Is Not Optional

One of the biggest takeaways was spending serious time in plan mode before jumping into implementation.

It’s not just about “What feature am I adding?”

It’s also about:

• Where does it live in the project?

• What dependencies does it affect?

• What files will change?

• What could break?

We were encouraged to (and it’s also best practice) to:

• Create a clear development process with phases where planning always comes first.

• Test each stage before moving to the next. This ensures you don’t have a backlog from the previous phase, creating a seamless development process.

• Separate planning from implementation. This is especially relevant when choosing which tool to use in planning, development, debugging, and even testing. Different models are better adapted/ more superior when you’re in different phases of your development

Looking back at my Russian doll project… I skipped that entire thinking process 😂.

I prompted first and thought later.

b) Context Is Everything When Using AI

Another key lesson is to always provide as much information as possible.

LLMs are powerful, but they don’t magically understand your entire project structure unless you show them.

We learned to:

• Feed documentation into the model.

• Work directly with official documentation for the languages, libraries, APIs, databases, etc., you plan to use.

• Provide a solid folder structure for your project. For this, you also have the option of feeding the LLM a project from another developer with a good folder structure that you’d like to implement.

• Be explicit about the environment and constraints of your project.

When you’re vague, the model fills in the gaps.

And sometimes… it fills them incorrectly.

That’s where hallucinations happen.

Not because AI is ‘bad’, but because it’s predicting patterns, not reasoning about your specific codebase unless you guide it properly. AI works better when it’s anchored in truth. The truth in this situation stands for context.

c) AI Is a Tool, Not a Substitute

There’s a difference between using AI to accelerate understanding and using AI to replace understanding.

And I had definitely been leaning toward the second 😂.

There are a lot of AI tools out there that greatly simplify the process of development, but at no point should they replace or will it ever replace the role that you play, the developer, in the development process.

So, what tools are these? This is when the masterclass got a bit technical.

Anthropic & Claude Code

Claude Code CLI is Anthropic's agentic coding tool that lives right in your terminal. What makes it stand out isn't just that it suggests code. It can autonomously take multi-step actions like editing files, running commands, managing git workflows, and navigating your entire codebase, all through natural language.

The keyword here is agentic. You're not just getting autocomplete. You're working alongside something that can understand the broader context of your project and act on it.

That said, it doesn't replace your judgment. Structuring your prompts well, being explicit about your environment, and critically reviewing every output are still entirely up to you. Claude Code amplifies what you bring to the table.

Anthropic also has a free course called Claude Code in Action, which covers best practices for integrating it into real development workflows (worth going through if you're serious about using it well).

And yes, some features do sit behind a paid subscription. Good tools usually tend to 😂.

Codex (Open AI)

Codex has evolved significantly. From my research, it's no longer just a code generation model. It's now a cloud-based software engineering agent.

What does that mean practically? You can assign it actual tasks, for example, write this feature, fix this bug, answer questions about this codebase. It works on them in parallel, each in its own isolated cloud environment preloaded with your repository. When it's done, it proposes the changes for your review, like a pull request from a teammate.

Codex isn't a tool you prompt and wait on. It's closer to a contributor you delegate tasks to. Which means the same rules apply; you still need to review what it produces before it goes anywhere near your main branch.

Playwright

Playwright is a testing framework, and it was highlighted as one of the most important tools you can add to an AI-assisted workflow, precisely because AI doesn't test its own output.

This tool handles end-to-end testing, meaning it can simulate real user flows through your application, such as clicking buttons, filling forms, and navigating between pages. It works across frontend and backend integrations and is especially strong for verifying that your UI components actually behave the way you think they should before deployment.

When you're vibe coding, there's a real temptation to assume things work because they look like they should. Playwright removes this assumption and replaces it with actual proof!

Kimi

Kimi is a multimodal AI assistant whose headline capability is genuinely impressive! You can hand it a screen recording or a screenshot of a website, and it will generate a working replica of the front-end code.

That's what puts it in a league of its own for frontend work. Not just describing what you want, but showing it. It's particularly powerful for recreating UI structures, replicating layouts, and generating clean animations without having to translate every design decision into words first.

If you're building frontends or prototyping quickly, Kimi K2.5 (its multimodal model) is the version worth exploring.

Remotion

Remotion lets you create videos programmatically using code, specifically React.

Instead of dragging timelines in a video editor, you define your video as a component. That means you can generate dynamic content, build product demos, and even automate entire media production workflows the same way you'd build a UI.

For developers building content tools, or anything that needs to produce visual media at scale, Remotion essentially removes the wall between your codebase and your video output.

Vibe Kanban

Vibe Kanban focuses on creating a structured workflow during vibe coding.

It’s not just a prettier task board. It's built specifically for managing multiple AI coding agents running at the same time.

When you're working with agents like Claude Code or Codex, you can technically have several of them working on different parts of your project simultaneously. But without structure, they'll step on each other, creating conflicting edits, tangled branches, and even broken builds.

Vibe Kanban automates the creation of git worktrees and runs setup scripts, so each agent works in its own isolated environment. You become the orchestrator by reviewing, approving, and directing, while your agents handle the execution in parallel.

It's a tool that makes the "multiple AI contributors" model actually workable in practice.

Skills

This one truly fascinated me.

Skills.sh is an open directory of reusable "agent skills". Self-contained modules that encode workflows, best practices, and domain expertise that you can install directly into your AI coding environment.

Think of it this way. Instead of hoping your AI agent defaults to good patterns and best practices, you give it a skill that tells it exactly what good looks like for your stack. Your architecture rules, your formatting standards, your naming conventions.

It's compatible with Claude Code, Codex, GitHub Copilot, Gemini CLI, Cursor, and others, so it's not tied to any one platform. And the impact is real. You stop relying on the model's generic defaults and start working with an agent that's calibrated to how you build.

That's the difference between an AI that codes and an AI that codes your way.

Arctype (Database Querying & Insights)

Arctype is a collaborative SQL client built for developers and teams. It's one of those tools that quietly solves a problem you don't realise is slowing you down until you use it.

Instead of digging through your backend or writing scattered queries in isolation, Arctype gives you a clean, fast interface to connect to your database, run queries, and visualise your data easily using built-in features.

Why does this matter in a vibe coding context? Because when something breaks, the problem isn't always the UI. It's not always the API. Sometimes it's the data itself that’s either stored incorrectly, related incorrectly, or simply not what you assumed it was.

Being able to quickly query your database and verify what's actually there shortens your debugging loop significantly. Arctype makes that fast, readable, and collaborative.

It's a reminder that full-stack thinking means understanding your data layer, not just your interface.

The Real Shift for Me

The biggest mindset shift?

AI is not a replacement for understanding.

It’s an amplifier.

If your structure is weak, it amplifies confusion.
If your architecture is clean, it amplifies speed.

Now I’m learning:

• Plan before prompting.

• Ground AI in documentation.

• Test intentionally.

• Treat AI as a collaborator, not an autopilot.

So… Am I a Vibe Coder?

Maybe.

But not in the way I thought.

Vibe coding isn’t inherently bad. In fact, it’s powerful. AI-assisted development is the future. Major corporations are actually encouraging their employees to integrate AI tools into their development. It increases speed, helps with boilerplate, and even clarifies ideas. And to be quite frank, AI can generate code faster than most humans can write it.

I don’t think the problem is vibe coding.

The problem is blind coding.

Coding without structure.
Prompting without planning.
Implementing without understanding.

That November incident wasn’t embarrassing because I asked for help or cause I built my project using AI. It was embarrassing because I didn’t fully understand what I had built, how I had built it, or what I had broken.

And that’s something I’ve already started changing.

So yes, maybe I am a vibe coder.
But now, I’m a structured one.
An intentional one.
One who plans before prompting.
One who tests before trusting.
One who understands before delegating.

And that’s why I can now wear my Vibe Coder Badge with so much pride and confidence :)

(Established in 2023 cause that's when I started my course lol 😂)

No more Russian dolls around here 🤣🤣🤣