How to Level Up Your Technical Skills in This AI Era

AI-assisted coding is here to stay. Tools like Cursor, V0, and Lovable have dramatically lowered the barrier to entry — building dashboards, pipelines, or entire apps can now be done in a fraction of the time.

I use these tools daily, and they’ve definitely made me faster. But as the codebase gets more complex, the tradeoffs become clear: cryptic bugs, tangled logic, and hours lost debugging code I didn’t truly understand.

AI tools are great — especially for beginners — but they come with a quiet cost. The more you let AI carry the load, the fewer chances you have to sharpen your instincts that come from wrestling with complexity. 

Yes, AI will speed up your workflow, but you’ll also skip the formative steps where technical wisdom is earned.

“Vibe coding” — quickly cobbling together code with minimal planning — is great for demos or experiments. But for deeper technical growth or building systems with meaningful complexity, vibe coding isn’t enough. This trending Reddit post sums it up perfectly: left unchecked, vibe coding creates more problems than it solves.

In this piece, I’ll show you how to use AI-assisted tools more wisely — and why contributing to Open Source might be the most underrated way to truly level up your technical skills.

My experience vibe coding with Cursor

Like many developers, I switched from VS Code (with GitHub Copilot) to Cursor and am currently subscribed to Cursor’s Pro plan ($20/month).

The feature I rely on most is Cursor’s integrated AI chat, which lets me directly interact with my entire codebase. Its agent can quickly grep through multiple files and even handle images - extremely useful when navigating large, unfamiliar repos. It also spots linter errors and auto-corrects them while directly editing files.

Initially, Cursor dramatically boosted my productivity, especially for simpler tasks. It felt powerful, almost magical. But as things got complex, I noticed some cracks. Cursor would sometimes generate spaghetti code, mix up similarly named files across directories, and occasionally struggle to follow intricate logic flows.

Vibe coding can get you thousands of lines of code in minutes  — but without a strong mental model of what you’re building, you risk ending up with bloated, over-engineered systems.

Cursor does a decent job narrowing down the search space when debugging. But letting it make unchecked edits does introduce even more bugs than it solves.

Beyond the usual advice to “write better prompts,” one strategy I’ve found especially helpful is telling Cursor NOT to make direct edits. (It’s surprisingly obedient about this!)

Instead, I explicitly ask it to suggest changes first in the chat interface. Then, I would review each suggestion, decide which edits made sense, and apply them selectively — either manually or through Cursor. Unlike ChatGPT, Cursor’s biggest strength is its contextual awareness of the entire codebase and its ability to parse through lengthy files (over 5k lines of code) by processing them in manageable chunks.

Contributing to open source

So, how do you get technically stronger? Two ways stand out: side projects and open source contributions. 

Side projects are great for exploring new tech or diving deep into something you’re passionate or curious about. Wonder how AI agents work or curious about MCP? Just building a simple weekend project teaches you far more than hours of tutorials or documentation. Thanks to open-source, tools and resources are freely accessible, leveling the playing field for everyone.

But solo projects have downsides. It’s easy to lose motivation — many of my own side projects never saw the light of day. 

Plus, you can find yourself in an echo chamber: your code works, but you’re not sure if it’s following best practices or industry standards. If you’re early in your career and lack mentorship, how do you know if you’re even on the right track?

This is exactly where open source fills the gap. Open source projects aren’t just for coding wizards; they’re for everyone. Your favourite libraries like Pandas, Matplotlib, TensorFlow, and Keras rely heavily on community involvement.

Why bother contributing?

Open source lets you make a real impact used by thousands of developers — not just toy projects nobody sees. You’ll become proficient with version control (hello, GitHub!), sharpen your skills navigating complex codebases, pick up best practices, and build a network of people who can vouch for you when it matters.

There are career benefits too. It’ll add to your portfolio and personal brand, and you’ll ramp up faster when joining new teams. 

But, contribute for the right reasons. If your only motivation is landing a job, DON’T contribute! Open source is not a ticket to get a job — it requires genuine interest and commitment. It shows you’ve a passion to build, and for many startups that begin from open source projects, that’s how they find their first hires.

Picking an open source project that you care about

Starting out can seem daunting. Many popular repos have enormous codebases, potentially outdated documentation, or hundreds of unclear issues. So how do you pick?

First up, pick a project you genuinely care about. This might sound obvious, but it’s crucial — and underrated. 

Choose something you actually use, whether at work or in a side project. Jumping into an unfamiliar project with unfamiliar tech is simply overwhelming, and you’ll lose motivation fast. 

Personally, I’m both a user and a big fan of PostHog  — the product analytics platform built specifically for developers — so I started contributing there. Their docs were comprehensive and well-structured, which made it an awesome place to start. (And no, they didn’t pay me to say this!)

What to contribute?

There are a ton of things you can do. Here’s an approach that I found helpful. 

1. Find a feature you need or improve something you use.
   Narrowing down contributions to features you genuinely care about gives clarity and motivation. The best code comes from solving problems you personally face.
2. Set up your local environment.
   Fork the project, clone it locally, and get it running. Understand where logs are and how to test changes. Get a grasp on the project’s basic structure and coding style.
3. Start small and learn by doing
   Many repos tag beginner-friendly issues (like “good-first-issue”). Pick these to start. Understand and replicate the bug; don’t hesitate to comment if you’re stuck. When you open a PR, ensure your changes pass all linting and tests.

Learning to navigate the codebase is essential. You don’t need to read every line — that’s practically impossible. After grasping the high-level structure, dive in. Start small to get comfortable with the build, deployment, and PR review process. Write clear commit messages and PR descriptions. Check recently merged PRs to see successful examples or insightful discussions.

Wrapping up

Contributing to open source takes patience — popular repos are huge, and learning takes time. Becoming a consistent, valuable contributor takes at least a few months, so don’t get discouraged by initial setbacks. If your PR is rejected or you get stuck on a tricky bug, that’s perfectly normal — it’s all part of the learning process. 

If you’re new to open source and want to chat, feel free to connect. While I didn’t dive deeply into technical details here (a quick Google or ChatGPT search can guide you there), I hope this gives you the big-picture perspective to get started. Open source has been rewarding for me — and I hope it will be for you too.

See you in the next article Read More