Every startup has a graveyard of "we'll fix it later" decisions.
The animation that's slightly janky. The form that takes 4 clicks when it should take 2. The 500 utility functions that all do basically the same thing. The config system that requires updating 8 files to add one option.
We tell ourselves it's fine. Ship now, polish later. Move fast, break things.
Later never comes.
Instead, you end up with:
- A codebase where fixing one bug creates two more
- A "standards" doc that's really just a list of exceptions
- 3am alerts because the nightly job is running again and the DB is at 100% CPU
- Engineers who spend more time understanding old code than writing new code
I've watched this happen at every company I've worked at. The technical debt compounds until "later" would take months.
AI Changed What "Later" Means
I'm building Flywheel solo using an AI-native codebase approach. Here's what's different:
I actually do the small things.
Not because I'm more disciplined. Because I finally have time.
Yesterday I spent 20 minutes tweaking a login page layout. Adjusting the transparency on a divider. Making the container width responsive to the form state. Small stuff.
A week ago I deleted 5,600 lines of over-engineered code and replaced it with 20 lines of config. Not because I had spare time - because Claude helped me systematically update 194 files without missing anything.
Last month I shipped a complete visual redesign in two weeks. New landing page, refined color palette, updated workflows across the entire application. That's a quarter's worth of work at most companies.
These aren't "nice to haves" I'm deferring. They're getting done now, while the context is fresh and the cost is low.
The Compound Effect of Doing Things Right
When you fix the small stuff immediately:
1. You don't accumulate exceptions.
Instead of "this works everywhere except X, Y, and Z" - it just works everywhere. No special cases to remember.
2. Your codebase stays navigable.
6 months from now, I won't be reverse-engineering my own decisions. The code says what it does because I had time to make it clear.
3. Bugs stay bugs - not symptoms.
When something breaks, it's actually broken. Not a cascade from some workaround three layers deep.
4. Onboarding stays fast.
New contributors (or future me) don't need a tour guide through the historical accidents.
Why Day 0 Matters
The best time to do things right is when you're writing the code. The context is loaded. The tradeoffs are clear. The cost is minimal.
Every day you wait, the cost goes up:
- More code depends on the bad pattern
- More people learn the workaround
- More exceptions get documented
- More tests encode the wrong behavior
AI doesn't just help you ship faster. It gives you back the time to ship correctly.
If you're starting something new in 2025, use AI from day one. Not to cut corners - to finally have time to care about the corners.
The Small Stuff I've Actually Done
Things that would have been "later" at a normal startup:
- Consistent loading states across every component
- Proper error boundaries with helpful messages
- Animations that feel intentional, not jarring
- Forms that remember your progress
- One way to do each thing (not three legacy approaches)
- Comments that explain why, not just what
- Tests that run in seconds, not minutes
None of these are impressive individually. Together, they're the difference between software that feels maintained and software that feels abandoned.
The Real AI Advantage
Everyone talks about AI making you 10x faster.
I think the real advantage is simpler: AI makes "do it right" and "do it now" the same thing.
You don't have to choose between shipping and quality. You don't have to accrue debt you'll never pay. You don't have to explain to your future self why the code is the way it is.
You just build it properly the first time, because you finally can.
What "later" tasks are piling up in your codebase? What would you fix if you had the time?
Top comments (1)
Some comments may only be visible to logged-in visitors. Sign in to view all comments.