Freelancing for a Travel Company Taught Me Everything About Tech Debt (and AI Misconceptions)

In early 2025, I took on a freelance project for Touring Highlights—a travel booking platform.

The hiring process was... unusual.

The Interview: "Build a Site With AI Only"

Here's how they found me:

1. Build a complete website using AI tools only
2. Document every single prompt you use
3. Submit the site and the documentation

I passed. First month was provisional.

This should have been my first warning sign. 🚩

But the pay was good. And I was curious. Those two things override pattern recognition more often than I'd like to admit.

Day One Discovery

When I got access to the codebase, I discovered something interesting:

The employer had already built a pre-existing site.

And guess what?

It was also vibe-coded.

We're talking AI-generated code that worked... kind of. The kind of code where you're scared to change one line because three unrelated features might break. I once fixed a button and the navigation menu started speaking French. I'm not joking.

Did you know? "Vibe coding" is when you keep prompting AI until something works, without fully understanding why it works. It's fast. It's dangerous. And it creates tech debt faster than a startup creates pivot slides.

The Reality of Building on AI Spaghetti

Here's what nobody tells you about inheriting vibe-coded projects:

Every new feature = Two jobs:

1. Build the actual feature
2. Refactor the code around it so it doesn't collapse

It's like renovating a house while the foundation is made of optimism and prayer.

Examples I Actually Encountered:

• Functions that did 17 things (AI loves throwing everything into one function like it's a garage sale)
• Variable names like data, data2, and finalData (spoiler: none of them were final, and data2 was actually a user object)
• CSS that looked like someone kept asking "just make it centered" until something stuck
• Comments that said // this works don't touch in every. single. file.
• One function called handleEverything(). It did not, in fact, handle everything. It handled about 40% of things and silently failed on the rest.

Did you know? I found a component with 847 lines of code. Eight hundred and forty-seven. For a dropdown menu. The dropdown had three options.

The Project Timeline

What was supposed to be:

Month 1: Build MVP features
Month 2: Launch beta
Month 3: Iterate based on feedback

What actually happened:

Month 1: Discover tech debt everywhere. Question career.
Month 2: Refactor while building (two steps forward, one step back, one step sideways into a wall)
Month 3: Still refactoring. The navbar works now though.
Month 4: Making progress, finally. Team morale cautiously improving.
Month 5: Project cancelled.

Narrator: The cautious optimism was not rewarded.

Why It Ended

The project ran for 4-5 months before it was cut.

The reasons were painfully typical:

1. No blueprint. The employer didn't have a clear project plan. Scope kept changing week to week. "Can we also add a booking system?" "What about a loyalty program?" "Actually, can we pivot to a completely different business model?" Sir, this is a travel website.

2. Funds ran out. AI-assisted development is fast, but fixing AI-generated code isn't. Turns out "we'll move 10x faster with AI" means budgeting for 10x the timeline anyway because someone has to clean up the mess.

3. Misconceptions about AI productivity. Building something with AI is quick. Maintaining something built by AI without human oversight is its own full-time job.

The AI Productivity Misconception

This is the lesson that stuck with me hardest:

AI boosts productivity. It doesn't do magic.

Here's what AI is great at:

• Scaffolding boilerplate
• Generating first drafts
• Explaining concepts
• Writing tests (sometimes. On good days. When Mercury is in retrograde but not TOO in retrograde.)

Here's what AI creates without human oversight:

• Tech debt that compounds daily
• Inconsistent patterns (three different ways to fetch data in one codebase!)
• Code that works for demo but breaks in production
• Maintenance nightmares disguised as "move fast" culture

The employer thought: "We'll move 10x faster with AI!"

The reality: We moved 2x faster on new code and 0.5x on everything else because we kept untangling AI spaghetti. Net productivity? About 1.25x. Worse if you count the crying.

Did you know? Studies show AI-assisted developers ship initial features 40-60% faster, but time spent on maintenance and debugging can increase by 30-50% if code quality isn't monitored. The net productivity gain depends heavily on code review discipline. Which we didn't have. Because there was no review process. Because "AI wrote it so it's probably fine."

Narrator: It was not fine.

What I'd Do Differently

If I took this project again:

1. Audit Before Committing

Before agreeing to the contract, I'd ask to see the existing codebase. Vibe-coded foundations = warning sign. If I see // this works don't touch more than twice, I'm negotiating a higher rate. Or running.

2. Budget for Refactoring

I'd explicitly include "tech debt time" in my estimates. Every sprint should have refactoring allocation. "But we don't have time for refactoring!" You don't have time NOT to refactor. That's how 847-line dropdowns happen.

3. Set Expectations Early

"AI-built code" doesn't mean "maintenance-free code." I'd explain this in the first meeting. With visual aids. Maybe a puppet show. Whatever gets the point across.

4. Document the Debt

Track every shortcut. Create tickets for future fixes. Make tech debt visible to non-technical stakeholders. If they can't see it, they assume it doesn't exist. Spoiler: it exists. It's lurking.

The Silver Lining

I learned more about real-world AI limitations from this project than from any tutorial.

AI is a power tool. Power tools in skilled hands create masterpieces. Power tools in unskilled hands create ER visits. Power tools in "we'll figure it out as we go" hands create... Touring Highlights.

The employer wasn't bad. They just believed the hype without understanding the trade-offs.

And honestly? A lot of the industry is making the same mistake right now. Every week I see "just use AI to build it faster!" and I think about that 847-line dropdown. And I sigh.

To Anyone Inheriting AI-Generated Code

1. Don't trust it. Assume every file needs review. Even the ones with confident comments.
2. Refactor as you go. Waiting until "later" means never. "Later" is a lie we tell ourselves.
3. Document your changes. You're building the documentation the AI didn't write.
4. Communicate often. Non-technical stakeholders need to understand why "it's already built" doesn't mean "it's ready." Explaining this is 30% of your actual job.

The project is over. The site was never launched.

But the lessons about AI, tech debt, and sustainable development?

Those are carrying forward to every project I touch now.

Sometimes the best education comes from the projects that fail. 💡

And sometimes, late at night, I still wonder what became of that 847-line dropdown. I hope it found peace. 🙏