introduction
AI-assisted coding tools like Cursor, V0, and Lovable have dramatically lowered the barrier to building software. You can scaffold an entire app in minutes, generate components from a prompt, and ship things faster than ever before.
But there are tradeoffs that aren't always obvious upfront. Cryptic bugs that take hours to unravel. Tangled logic that nobody — including you — fully understands. Debugging code you didn't write and can't reason about.
"Vibe coding" is great for demos and prototypes, but it's not a substitute for deeper technical growth. If you lean on it too heavily without understanding what's happening underneath, you end up stuck — unable to fix things when they break, unable to extend things when requirements change.
my experience vibe coding with Cursor
I switched from VS Code with GitHub Copilot to Cursor Pro ($20/month). The appeal was obvious — AI chat integrated directly with your entire codebase. The agent can grep through files, handle images, and suggest changes across multiple files at once.
For simpler tasks, it was a genuine productivity boost. Spinning up boilerplate, writing tests, small refactors — all faster.
But for more complex work, things got messy:
- Spaghetti code — the AI would generate sprawling, tangled implementations
- Mixing up similarly named files — it would edit the wrong component or reference the wrong module
- Struggling with intricate logic — anything requiring careful reasoning across multiple layers would fall apart
The strategy I landed on: tell Cursor not to make direct edits. Instead, ask it to suggest changes first in chat. Review the suggestions, understand what it's proposing, then apply selectively. This keeps you in the driver's seat and forces you to actually learn what's changing in your codebase.
contributing to open source
There are two main ways to get technically stronger outside of your day job: side projects and open source contributions.
Side projects are great for exploring new technologies and building things on your own terms. But they come with downsides — it's easy to lose motivation when there are no external deadlines or users, and you end up in an echo chamber of your own patterns and habits.
Open source fills that gap nicely.
why bother contributing?
- Real impact — your code gets used by thousands (or millions) of people
- Technical growth — you become proficient with version control, navigating complex codebases, and engineering best practices
- Networking — you interact with experienced engineers and maintainers
- Career benefits — contributions are visible on your GitHub profile, building your portfolio and personal brand
But contribute for the right reasons. Don't treat it purely as a resume-padding exercise to land a job. The best contributions come from genuine interest and curiosity. Maintainers can tell the difference.
picking an open source project that you care about
The most important thing is to pick something you genuinely use. If you're already a user, you understand the product, you know its quirks, and you have context that makes your contributions more meaningful.
I contribute to PostHog, which I use regularly. The docs were comprehensive and well-structured, which made onboarding as a contributor much smoother. Good documentation is a signal that a project values its contributors.
what to contribute?
Getting started can feel overwhelming. Here's a practical approach:
- Find a feature you actually need — the best motivation is scratching your own itch
- Set up the local development environment — follow the contributing guide, get the project running on your machine
- Start small — look for issues tagged with
good-first-issue. These are specifically curated for newcomers - Learn to navigate the codebase — spend time reading code before writing it. Understand the architecture, patterns, and conventions
- Write clear commit messages and PR descriptions — explain what you changed and why
- Check recently merged PRs — this is an underrated tip. Reading recent PRs shows you the team's standards, code style, and review expectations
wrapping up
Becoming a consistent open source contributor takes patience — at least a few months of regular effort before it starts to feel natural. Don't get discouraged by rejected PRs or tricky bugs. That friction is where the real learning happens.
The combination of using AI tools wisely and contributing to open source is a powerful way to grow. Let the AI handle the tedious parts, but make sure you understand what's going on. And when you're ready to push yourself further, open source is waiting.