DEV Community: Andy Osyndoh

Are We Taking "Clean Code" Too Far?

Andy Osyndoh — Sun, 03 Aug 2025 17:54:31 +0000

I’m going to say it: We spend too much time on ‘clean code.’

Before you grab your pitchforks, hear me out.

I’m not saying you should write unreadable spaghetti that future you (or worse, your teammates) will hate. Maintainable code is essential. But somewhere along the way, the software community took “clean code” from a useful principle to an almost religious pursuit and in that transition, we may have lost sight of what really matters: shipping value.

In many engineering conversations today, there's an implicit assumption that elegance equals impact. That if we just refactor one more time, abstract one more layer, or write a more generic utility, the codebase will magically become better; more pure, more professional. But here’s the uncomfortable truth:

A perfectly architected system that never ships is just a very expensive distraction.

The Paradox of Perfection

I’ve seen it firsthand and I’ve been guilty of it too. You open your editor, ready to solve a business problem. But instead of building the MVP, you spend hours tweaking the folder structure, setting up elaborate test frameworks, and debating whether your dependency injection layer should be inverted twice for maximum decoupling.

You tell yourself you’re being a “professional.” But deep down? You might just be avoiding risk.

There’s a reason this happens. Clean code feels good. There’s comfort in refactoring, in polishing functions, in renaming things until the abstractions line up like poetry. But if the code you’re cleaning isn’t solving real user problems yet, what’s the point?

Sometimes, we’re just polishing the engine while the car is stuck in the mud.

Quick Wins vs. Clean Wins

Lately, I’ve been diving into some projects that reminded me of this distinction and how easy it is to forget.

For example:

I was building a SimHash-based text indexing tool in Go and the first version? Super hacky. But it proved the idea worked. Chasing the perfect hash table implementation would’ve slowed me down before I even validated anything useful.
In a recent GraphQL project, I needed JWT auth and SVG graphs working in days, not weeks. Did I write reusable auth middleware for every case? No. I hardcoded it first. Then, once it worked and the UI displayed real data, I cleaned it up.
With our Tetris Game concept, we didn’t start with the architecture. We built a lean prototype to show the framework itself could work. That early test was more important than the code elegance behind it.

In all these cases, speed mattered more than perfection. Not because I don’t care about clean code but because I care more about outcomes.

When Clean Code Becomes a Crutch

Here’s the thing no one tells junior developers: the codebase that wins isn’t always the cleanest one. It’s often the one that ships fast, learns from real users, and adapts based on actual demand.

I’ve talked to developers who are afraid to launch unless their repo looks like something out of a textbook. I get it, no one wants to be judged. But this fear can kill momentum. Clean code is supposed to help teams move faster and collaborate better. But when it becomes a crutch, or worse, a bottleneck; it loses its purpose.

You can always refactor. But you can't retroactively launch sooner.

What Clean Code Isn’t

Let’s be clear: I’m not dismissing clean code. In fact, I’m a fan of:

Meaningful names
Separation of concerns
Avoiding duplication
Testing critical logic
Clear, modular structure
Well documented code

But clean code isn’t:

Writing ten layers of abstraction before your first commit
Premature optimization for traffic you don’t have
Spending a week writing tests for code that changes daily
Obsessing over file structure instead of user experience

Clean code is a tool. Not a trophy.

Shifting the Mindset

So how do we balance craft with progress?

Here’s what’s worked for me lately:

Build ugly first. Get something working. Then assess if it's worth refactoring.
Solve user problems early. Code that delivers real value will guide better design decisions.
Make decisions reversible. Favor flexible choices over rigid perfection.
Refactor after feedback. Let real-world use cases shape the system, not abstract idealism.
Ship often, improve continuously. Feedback is your friend. Don’t wait for “perfect.”

In Summary

Clean code matters, but only in service of something greater. Don’t fall into the trap of code aesthetics over code purpose.

It’s okay to write “ugly” code that solves the problem today. You can always refactor tomorrow. But an unlaunched, over-engineered masterpiece? That’s just technical debt in disguise.

So next time you catch yourself reaching for one more layer of abstraction, ask:

“Am I solving a real problem or just avoiding the hard part?”

Let’s build with purpose. Clean enough to maintain, fast enough to matter.

Deciphering Collaboration

Andy Osyndoh — Sat, 29 Mar 2025 12:20:27 +0000

Nicholas Sadirac, the creator of the pedagogy used in schools such as Epita, Epitech, 42, and Zone01, believes in collective intelligence. This means that learners come together to share knowledge and skills. How do they achieve this? By collaborating on various projects while learning. At first, one might think collaboration is simple—form a group, complete the task, and move on. After a year at Zone01, working with different learners on various projects, I can confidently say it’s easy. However, what collaboration consists of is what makes it feel hard, but we all have to collaborate. So how do we navigate it? Over time, I’ve learned key principles that have helped me collaborate effectively and produce great results. Let me share them with you.

Trust Your Group Members to Deliver

I know trust doesn’t come easily, but hear me out. Imagine a scenario where tasks are delegated among group members with a set deadline—stick to your task, and let others stick to theirs. In a bee colony, foragers collect nectar, pollen, water, and propolis, while nurse bees care for the larvae. If foragers suddenly took over the role of nurse bees, the colony would starve. Even in a bee colony, the queen releases pheromones to maintain unity. Likewise, a group needs a leader to keep everything running smoothly.

Often, we get distracted by someone else’s work—if you need to step in, make sure the task owner is aware and comfortable with it. But don’t neglect your responsibilities. A good leader ensures each member knows their role and holds them accountable while providing support where needed. Delegation without micromanagement is key.

Never Underestimate Your Group Members

One lesson I’ve learned is that I don’t know everything—and I never will. There’s always someone in the room who is better than me at a particular skill, sometimes even the person I least expect. When someone is assigned a task, even if you doubt their ability, let them do it. Until they ask for help or it becomes clear they’re struggling, allow them to grow. The best way to learn is through doing. If we don’t allow people to try, they’ll never learn. So, avoid stepping into someone else’s work unless it’s truly necessary.

Accountability plays a crucial role in team success. Each member should take ownership of their work and deliver to the best of their ability. Setting clear expectations from the beginning helps reduce misunderstandings and excuses.

Keep Communication Open

Sharing information within a group is crucial. Be reachable, communicate, and express your ideas clearly. Stick to schedules, and if you can’t make it on time, inform the group in advance. Also, be a good listener—when someone shares information, process it before responding. Never dismiss someone’s idea outright. Be open to different perspectives, respect others’ opinions, and honor their work.

Never overwrite someone’s contributions without discussing it—imagine spending the entire night coding, only to wake up and find your work replaced with another version that does the same thing. That can be frustrating and demotivating. Conflict resolution is just as important—when disagreements arise, address them constructively. Set up regular check-ins to ensure alignment, and if tensions escalate, involve a neutral mediator to guide the discussion.

Don’t Focus on Noise

Always consider the main goal of the group. Why are we doing this? What is our aim? When we answer these questions, we stay focused. Distractions come from both inside and outside the group. We often assume external noise is the bigger threat, but history shows that the greatest empires—like the Roman Empire, the Soviet Union, and the Qing Dynasty—collapsed from within. Internal issues develop slowly over time and can be hard to recognize. Some of the internal noise might include misunderstandings in the group, poor leadership, poor communication, or even a lazy group member who does not live up to their task. Address them early to maintain momentum and prevent the team from falling apart.

Use the Available Tools

We are more than 24 years into the 21st century, and we have a wealth of resources to make collaboration more efficient. Tools like GitHub, Miro, Slack, and Notion help streamline teamwork. Utilizing pull requests, issue tracking, and wikis can keep everyone aligned. Making short, clearly defined commits allows for easier tracking and debugging. This can be a lifesaver when a problematic code block affects overall functionality.

For real-time collaboration and project management, consider:

Trello or Asana – Task management tools to keep projects organized.
Google Docs & Notion – Seamless document collaboration.
Slack or Microsoft Teams – For communication and quick updates.
Jira – Best for agile teams managing software projects.
Figma – For design collaboration.

Using these tools ensures that tasks are visible, responsibilities are clear, and everyone stays updated.

Final Thoughts

When we join a group to work, we all hope for the best. We want to see the project succeed. Coming together, working cooperatively, and achieving a shared goal is priceless. Having good chemistry within the team is incredibly fulfilling.

To collaborate effectively:

Trust your team members and hold them accountable.
Communicate openly and resolve conflicts constructively.
Stay focused on the goal and minimize distractions.
Use modern collaboration tools to stay organized.

By embracing these principles, we can create a strong, productive, and harmonious team environment. We should always strive to give our best for the success of the project.