This weekend, I did something that changed how I think about building products.

I spent hours in my backyard, cutting back overgrown shrubs and dragging piles of branches to the curb. Hard work, but when I finished, everything was clear. Everything was clean.

I felt lighter.

Then it hit me - my side projects needed the same care.

We talk a lot about shipping fast and building new features. But nobody talks about pruning - the deliberate act of cutting away what doesn't serve you anymore.

And honestly, it might be more powerful than building new stuff.

The Problem with Never Looking Back

Here's what happens when you only focus on building new things:

Your codebase becomes a mess. You have files you forgot about. Functions that do nothing. Variables named "temp" that became permanent. Comments that made sense 6 months ago but don't anymore.

I realized my side project had become like my overgrown garden:

• Branches (features) growing in all directions
• Dead code that should have been removed months ago
• Tangled logic that made simple changes complicated
• No clear structure or organization

The worst part? Every time I wanted to add something new, I had to navigate through all this mess first.

It was slowing me down more than I realized.

What I Found When I Started Pruning

After my garden epiphany, I decided to give my main side project the same treatment.

Here's what I discovered when I actually looked at what I had built:

Unused Files Everywhere

I found 47 files that weren't being used anymore.

Components I had built and then rebuilt. Utility functions I had replaced but never deleted. CSS files for features that no longer existed.

Each unused file was like a weed. It didn't seem like a big problem by itself, but together they were cluttering everything.

Stale Git Branches

I had 23 old branches that should have been deleted months ago.

Some were experiments that didn't work out. Others were features that got merged but the branches stayed around. A few were attempts at fixes that I had given up on.

Cleaning these up made my repository feel organized again.

Over-Engineered Logic

I found code I had written months ago that was way more complicated than it needed to be.

Functions with 5 parameters when they only needed 2. Classes when simple functions would have worked. Abstractions that made the code harder to understand, not easier.

Past me thought I was being clever. Present me realized I was being stupid.

Missing Documentation

The stuff that actually mattered had no documentation.

I had spent time commenting obvious things but left the complex business logic unexplained. Future me (and anyone else who might look at this code) would have no idea why certain decisions were made.

The Pruning Process That Actually Works

Here's the system I developed for cleaning up my projects:

Step 1: Delete Unused Files

Start with the obvious stuff.

Look for:

• Files that aren't imported anywhere
• Components that aren't used
• Utility functions that have been replaced
• CSS that doesn't apply to anything
• Images that aren't referenced

I was surprised how much lighter the project felt after removing just the unused files.

Step 2: Clean Up Git History

Delete old branches and organize what's left.

Commands I used: ```bash

Delete merged branches

git branch --merged | grep -v master | xargs git branch -d

Delete remote tracking branches that no longer exist

git remote prune origin

Clean up stale references

git gc --prune=now ```

This made my git history much easier to navigate.

Step 3: Refactor Messy Logic

Look for code that makes you cringe.

Ask yourself:

• Would I write this the same way today?
• Is this as simple as it could be?
• Would someone else understand this?
• Am I solving the right problem here?

Don't rewrite everything. Just fix the stuff that actively hurts to look at.

Step 4: Simplify Over-Engineering

Remove abstractions that don't add value.

I found several places where I had built complex systems for simple problems. A function that took 5 parameters when it really only needed 1. A class hierarchy for something that could be a simple object.

The goal is clarity, not cleverness.

Step 5: Document What Actually Matters

Write comments for future you.

Focus on:

• Why you made certain decisions
• What business logic is being implemented
• How different parts of the system connect
• What would be confusing to someone new

Don't document obvious things. Document important things.

What Changed After Pruning

My Development Speed Doubled

I could find things faster. I could understand my own code again.

Adding new features went from "Let me figure out how this works again" to "Oh right, I just need to modify this function."

Less time spent navigating mess = more time building features.

Bugs Became Easier to Fix

When your codebase is clean, bugs stick out.

Before pruning, bugs could hide in the mess. After cleaning up, problems were obvious.

I also stopped creating new bugs because I understood my code better.

I Actually Enjoyed Working on the Project Again

There's something satisfying about working in a clean codebase.

Instead of feeling overwhelmed every time I opened the project, I felt excited to work on it.

Clean code is motivating. Messy code is draining.

Onboarding Others Became Possible

I had been thinking about getting help with the project but the codebase was too messy to share.

After pruning, I could actually explain how things worked. Someone else could look at the code and understand it.

Clean code enables collaboration.

The Mindset Shift That Changes Everything

Pruning isn't just about cleaning up code. It's about changing how you think about building.

Instead of:

• "I need to add more features"
• "I need to ship faster"
• "I need to build more things"

Think:

• "What can I remove?"
• "What can I simplify?"
• "What can I make clearer?"

Building is addition. Pruning is subtraction. Both are necessary.

When to Prune Your Projects

Weekly: Quick Cleanup

Spend 30 minutes each week doing basic maintenance:

• Delete files you know you don't need
• Remove commented-out code
• Clean up imports
• Delete old console.log statements

Monthly: Deeper Review

Spend 2-3 hours each month on deeper cleanup:

• Refactor functions that have gotten messy
• Update documentation
• Remove features nobody uses
• Simplify complex logic

Quarterly: Major Pruning

Spend a full day every 3 months doing major cleanup:

• Delete entire features that aren't working
• Restructure file organization
• Update dependencies
• Rewrite problematic code

Think of it as spring cleaning for your codebase.

The Part-Time Founder Challenge

When you're building on the side, every minute matters.

You might think maintenance is a waste of time. You only have a few hours each week - shouldn't you spend them building new features?

But here's the thing: mess compounds.

Every piece of technical debt makes future work harder. Every unclear piece of code slows you down next time.

Pruning isn't overhead. It's an investment in your future productivity.

What You Can Prune Right Now

If you're working on a side project, here's what you can clean up this weekend:

In Your Code:

• Files you haven't touched in 3+ months
• Functions longer than 50 lines
• Variables with names like "temp" or "test"
• Commented-out code you "might need later"
• Dependencies you installed but don't use

In Your Project:

• Features nobody actually uses
• Half-built experiments you abandoned
• Over-complicated workflows
• Unnecessary abstractions
• Duplicate functionality

In Your Process:

• Tools you don't actually use
• Meetings that don't add value
• Steps in your workflow that slow you down
• Notifications that distract you
• Commitments that don't serve your goals

The Long-Term Benefits

Pruning creates compounding benefits:

Better Performance: Less code means faster loading and fewer bugs.

Faster Development: Clean code is easier to modify and extend.

Less Stress: Working in a clean environment is mentally easier.

Easier Collaboration: Other people can actually understand your project.

Better Decision Making: When you can see clearly what you have, you make better choices about what to build next.

Your Next Steps

Don't wait until your project becomes a mess.

Build pruning into your regular routine:

1. This Week: Spend 1 hour deleting obvious junk
2. This Month: Refactor one messy part of your codebase
3. This Quarter: Do a major cleanup of your main project

Remember: Shipping is fun, but pruning is power.

Your future self will thank you for taking the time to maintain what you've built.

What are you going to prune first?