Stepping Back to Build a Stronger Foundation

A while ago, I was regularly sharing updates about the progress of building my POS application.

From the outside, things looked like they were moving forward. Features were getting built, ideas were taking shape, and development seemed productive.

But somewhere along the way, I started losing confidence in the direction of the project.

It wasn’t because the idea had changed.

The real issue was the development process itself.

When AI Stops Feeling Helpful

A significant part of the workflow had become dependent on AI guidance.

At first, it felt incredibly useful. It helped me move faster, suggested implementation details I hadn’t considered, and reduced the friction of getting started.

Over time, though, something felt off.

The guidance became less consistent. Different suggestions led to different patterns. Decisions that seemed reasonable one day conflicted with recommendations from another session. I found myself following instructions without fully understanding the reasoning behind them.

That realization was uncomfortable.

I wasn’t just shipping features anymore. I was participating in a process that I couldn’t confidently explain or defend.

And that’s not the kind of foundation I want to build on.

Choosing to Pause

So I decided to pause the POS project.

Not because I had lost interest in it.

Not because I believed the project had failed.

I paused because I needed to regain clarity.

It’s tempting to keep pushing forward simply because you’ve already invested time and effort. But continuing with uncertainty often creates more problems later. Technical debt isn’t always about messy code. Sometimes it’s a collection of decisions you don’t fully understand but keep building on anyway.

I didn’t want the project to become that.

Building My Own Next.js Boilerplate

These days, my focus has shifted toward building my own Next.js boilerplate.

I’m still using AI during the process. In fact, tools like Gemini CLI have been genuinely helpful.

The difference is in how I use them.

Instead of treating AI output as instructions to follow blindly, I’m using it as a discussion partner and an accelerator. I question suggestions, ask for alternatives, explore trade-offs, and adapt ideas to fit my own understanding.

The goal isn’t just to create another starter template.

I want to build a foundation that’s:

• Reusable across multiple projects.
• Scalable as requirements grow.
• Consistent in its development flow.
• Based on architectural decisions I genuinely understand.

That means thinking carefully about things like:

• Folder structure and project organization.
• Data fetching patterns.
• Form handling approaches.
• Abstraction layers and boundaries.
• Conventions that make development more predictable.

It takes more time upfront.

But I believe that investment pays off later.

Returning With Better Tools

The POS application hasn’t been abandoned.

The plan is to return to it once this boilerplate reaches a level of maturity I’m comfortable with.

And hopefully, it won’t only benefit that project.

The same foundation can support future ideas as well.

Instead of rebuilding the same decisions over and over again, I’ll have a system that reflects the lessons I’ve learned along the way.

More importantly, I’ll understand why those decisions exist.

Stepping Back Isn’t Giving Up

As developers, we often celebrate momentum.

Shipping quickly.
Posting progress updates.
Crossing features off a checklist.

Those things matter.

But sometimes, the most valuable decision is to stop and reassess.

To admit that the current process isn’t working as well as it should.

To rebuild the parts that need rebuilding.

To trade short-term progress for long-term confidence.

Stepping back for a while doesn’t always mean giving up.

Sometimes, it’s simply how you build a stronger foundation before moving forward again.