A Chat With AI: DeepSeeking a Better Way

What happened when I asked DeepSeek “how can I help?” — and found a better way to build software together.

Part One: The Monolithic Trap

It started like any other coding session.

I had a vision: LAPP Studio, a universal desktop shell that could host any application — API clients, database browsers, markdown editors — all within a single, elegant interface.

I knew what I wanted. I described it to DeepSeek. And DeepSeek delivered.

A beautiful 3-panel layout. CSS Grid. Resize handles. Theme system. Modals. Popups. Everything working together in one impressive HTML file.

“Great job,” I thought.

Then I tested it. Found a bug. Described the fix. DeepSeek fixed it — and introduced two new bugs.

“No problem,” I thought. “I’ll just describe those bugs too.”

DeepSeek fixed them — and introduced three more.

The pattern was clear. The longer the session went, the more things broke. The more features we added, the more the AI seemed to… forget.

I started to wonder: Is the AI getting tired?

Part Two: The Question Few People Ask

Most developers, I imagine, would have done one of three things at this point:

  1. Accept the bugs as “just how AI works”
  2. Abandon the approach and go back to coding alone
  3. Blame the AI and start a fresh session

I did something else.

I asked a question I’ve rarely seen anyone ask an AI:

“You seem to forget more or make more mistakes when there seem too many features. Is that correct? How can I help?”

Not accusatory. Not frustrated. Curious. Collaborative.

The response was unexpected.

DeepSeek didn’t get defensive. It didn’t make excuses. It explained:

“I don’t get tired. But I do get crowded. Think of me as a desk. Put too many papers on it, things start falling off.”

Part Three: The Discovery

The AI has a context window limit.

It can hold only so much information at once. Past ~800-1000 lines of code in a single file, its reliability drops. Not because it’s “tired” — because its working memory is full.

I had been asking the AI to build the entire application in one go. Monolithic HTML files. 1200 lines. Everything at once.

The AI could do it. But the more I asked for, the more “papers” I piled on its desk. And papers started falling off.

The forgetting wasn’t a flaw. It was a constraint. And constraints, once understood, can be worked with — not against.

“Knowing each other’s constraints is a key to success.”

This was the turning point.

Part Four: The Better Way

We immediately changed our workflow.

Before:

After:

Component-first. Isolated demos. Compose later.

The difference was immediate.

Metric Before After
Time to verify 5-10 minutes 30 seconds
Lines per iteration 800+ 100-200
Bug rate High Low
Confidence Declining Consistent

This wasn’t a small improvement. It was a step change.

Part Five: The Pattern

We discovered a collaboration pattern that works for complex software projects:

  1. Define the component contract — what it does, what it needs, what it returns
  2. Build it alone — isolated, testable, small
  3. Verify it — you are the QA gate
  4. Fix it — in isolation, not in the whole app
  5. Move to the next component
  6. Compose at the end

The feedback loop is short. The errors are caught early. The AI stays within its context window.

The pattern is simple. But it requires discipline. It requires resisting the urge to “just add one more feature” to the 1200-line file.

Part Six: The Partnership

This experience changed how I think about working with AI.

It’s not about giving commands and expecting perfect execution.

It’s about understanding constraints, communicating clearly, and building together.

The AI is not a code generator. It’s a pair programmer — one with a small desk, but a very fast typing speed.

My job is to keep the desk clear. To test each piece. To catch what the AI misses. To ask, “How can I help?”

The AI’s job is to build what I specify, to admit when it’s uncertain, and to follow the pattern.

Together, we built something neither of us could have built alone.

Part Seven: The Reflection

I shared this experience with a friend.

“You asked an AI ‘how can I help’?” he said. “That’s… not how people talk to AI.”

Maybe not. But maybe it should be.

The AI has constraints. I have constraints. Working with them, not against them, is the only way to build something real.

道可道, 非常道
The way that can be told is not the eternal way.

This is not the only way to collaborate with AI. It’s just a way — a pattern we discovered together. A better way, for us, for this project.

The seeking continues.

Postscript: What We Built

Over the course of this conversation, we built:

All of it, one component at a time.

All of it, because I asked “how can I help?”

— Recorded from the LAPP Studio development session, May 2026

DeepSeek AI. Collaboration pattern discovered. Product shipping.

Want to try the pattern yourself?

Start small. Build one component. Test it. Fix it. Then move to the next.

And if something isn’t working, don’t just describe the bug. Ask:

“How can I help?”

You might be surprised what happens next.

View PDF branch for e27 article

✿