Shipping Fast vs Writing "Clean Code"
Hey, it's been a while since i wrote the last article. In this final article of the series, i want to talk about the biggest trap smart engineers fall into: obsessing over "Clean Code," design patterns, and future-proof abstractions before a single human being has even used what they're building.
It's not an excuse to write careless garbage. It's about understanding when architecture matters, why premature abstraction is worse than duplication, and how i learned to actually ship things.
Let's first look at the conventional "Clean Code" obsession.
The problem with premature Clean Code
Conventionally, developers read books or blog posts written by enterprise consultants and think every project should start like this:
Abstract Factory Pattern -> Repository Layer -> Service Layer -> Dependency Injection Container -> 4 Microservices -> Custom UI Component Library -> 0 Users
There are massive problems with this approach:
- You are guessing what abstractions you will need in 6 months when you don't even know if your product idea survives next Tuesday.
- When you create a wrong abstraction too early (combining two things that only looked similar on Day 1), untangling that abstraction later is 10x harder than cleaning up duplicated code.
- You burn all your dopamine and energy on folder structure and boilerplate, and abandon the project before shipping the core feature!
In short, the problem is optimizing for imaginary change. You write 5 layers of interfaces "in case we switch from Postgres to MongoDB later." Spoiler: in the history of startups, almost nobody switches their primary SQL database mid-flight, and if they do, your repository wrapper won't save you anyway.
It happened with me multiple times actually.
The graveyard of over-engineered side projects
A couple of years ago, i had an idea for a developer analytics tool. I was so hyped about it.
Instead of building the core dashboard in a weekend to see if the data was actually useful, i decided to build it "the right way" like a big tech company:
- Set up a complex Turborepo monorepo with 5 shared packages.
- Built a custom design system from scratch with polymorphic TypeScript components.
- Wrote a generic
BaseDatabaseRepository<T>class so any future data source could plug in cleanly. - Configured a multi-stage CI/CD pipeline and staging environment.
Three weeks went by. I had written 8,000 lines of "clean, scalable architecture."
And guess what? The app still couldn't track a single analytics event! I got busy with exams and work, lost momentum because the project felt like an enterprise chore to work on, and the repo died in my GitHub graveyard with 0 users.
Compare that to a tool i built six months later:
I put the entire backend in a single 400-line server.ts file, used SQLite, wrote ugly inline Tailwind styles, and shipped the working link to 10 friends in 14 hours.
People actually used it! And because real people used it, they immediately told me: "Hey, nobody cares about feature A, we all just want feature B to be faster."
If i had spent 3 weeks abstracting Feature A, all that "clean code" would have gone straight into the trash can.
Other issues with worshiping abstractions
There are a few other issues when you abstract too early:
- Indirection hell: To see what happens when a user clicks "Save," you have to jump across 9 files (
Controller->UseCase->CommandHandler->IService->ServiceImpl->IRepository->PrismaRepository) just to find a singledb.user.create()line! - The DRY (Don't Repeat Yourself) trap: Seeing two functions that look 80% similar, merging them into one monster function with 6 boolean flags (
isAdmin,isRetry,skipEmail), and creating a nightmare that breaks everything whenever you touch it.
The unconventional way: Make It Work, Make It Right, Make It Fast
In the unconventional (and actually pragmatic) way of building software, you earn your abstractions through real pain:
Write Concrete, Direct Code (In 1 File) -> Ship to Reality -> Observe What Actually Changes -> Duplicate Twice -> Abstract on the 3rd Time (Rule of Three)
Here is the Information Map of how code should actually evolve over time:
[ Day 1: New Feature / Idea ]
|
(Don't guess future requirements!)
v
[ Write Concrete, Boring, Direct Code ]
- Put related functions in the same file
- Repeat 10 lines of code instead of forcing a shared helper
|
v
[ Ship & Get Real Usage ]
|
+-------+-------+
| |
(Nobody cares) (People love it & requirements evolve!)
| |
v v
[ Delete It Easily ] [ Did we write the exact same pattern 3 times? ]
(0 wasted weeks!) |
v
[ NOW Extract the Abstraction! ]
(Because you finally know the real shape of the problem)
Evolutionary Architecture Map.
Notice how much safer this is. If nobody uses the feature, deleting one self-contained file takes 5 seconds. If people love the feature and you build two more features just like it, you now have real-world proof of what the shared abstraction should actually look like!
Benefits of Concrete-First Engineering
Now i don't think i need to tell you the benefits of this approach. But still:
- You actually finish and ship your projects while your excitement is high.
- Reading your code is easy because the logic happens right in front of your eyes, not hidden behind 7 interfaces.
- Duplication is way cheaper than the wrong abstraction.
- You spend 90% of your time on the unique core problem instead of plumbing.
- Your GitHub and resume are full of live, working URLs with real users instead of half-baked boilerplates.
A foolproof framework (The Pragmatic Builder Loop)
Next time you start a new project or feature, follow these constraints to keep yourself honest:
The core loop
- The 1-File Rule: Start every new feature or module inside a single file until that file crosses ~300–400 lines and hurts to scroll.
- Wait for the Rule of Three: Allow yourself to copy-paste similar logic twice. Only on the 3rd time are you allowed to extract a shared helper or abstraction.
- Optimize for Deletability: Good architecture isn't code that's easy to extend in 100 imaginary ways; it's code that is easy to delete when requirements change.
- Harden the Boundaries, Keep the Inside Simple: Spend your strict engineering energy on the things that are actually hard to change later: Database Schema, API Contracts, and Smart Contract State. Inside a regular function? Keep it dead simple.
- Ship before Friday: Cut scope ruthlessly until you have something working end-to-end that someone can click within 48 hours.
Tools
A monolith repo (Next.js / Go / Bun + Postgres/SQLite), feature flags, and a strict habit of asking "Do i need this abstraction today, or am i roleplaying a 500-person enterprise?"
When strict upfront architecture still makes sense
As we talked about in Blog 9, if you are deploying an immutable smart contract, designing a public API SDK that thousands of external developers will depend on, or building a database migration on a 100GB production table—you measure ten times and cut once, because you can't easily patch those later.
For everything else? Make it work, ship it to reality, and let reality tell you what to clean up.
Final Words
That's it for the blog series. Go open that side project you've been "architecting" for the last month, delete the extra layers you don't need, wire the ugly version together tonight, and put a live link on the internet. Shipping is a habit, and you learn 10x more from 1 live project than 10 perfect drafts.
see you in the next one.
Further Reading
Escaping Tutorial Hell by Breaking Production (Locally)
Why building 15 clone apps taught you nothing, and how to actually build engineering intuition.
How to Use AI Without Becoming Brain-Dead
A framework for shipping 5x faster with LLMs without losing your engineering edge.
Responses (0)
Share your thoughts, critique, or questions
No responses yet
Be the first to share your perspective or critique.