Building a Thinking Space With the Thing I Was Thinking About

The tools that almost made the cut

I didn't want a template. I wanted a space that thought the way I think structured but not rigid, opinionated but not closed. So before I wrote a single line, I spent time with the options.

Replit was interesting for throwaway prototyping. But it felt like renting someone else's kitchen: convenient until you wanted to move the stove.

The AI-first no-code tools , Loveable and its siblings were genuinely impressive at getting something on screen. Fast, polished, democratically good-looking. But the moment I wanted something non-standard a custom AI chat with a specific briefing, a layout decision that wasn't in the template library, a data model I actually controlled the walls came up fast. Beautiful scaffolding. Limited headroom. These tools are optimized for the 80% case, and they're excellent at it. I was living in the remaining 20%.

Then I tried Claude Code, Anthropic's CLI tool. This is where something clicked that hadn't clicked with the others.

It's not a no-code tool. It's not a code generator you paste from. It's closer to pairing with a very fast engineer who has read everything, never gets annoyed at your questions, and will tell you when your approach is wrong if you've set up the dynamic right. I could describe what I wanted at the level of intent, push back on what it generated, and make deliberate choices about the stack. The difference between Claude Code and the no-code tools isn't speed. It's headroom. There's no ceiling you hit because the platform didn't anticipate your use case.

Why the stack is the argument

I landed on Next.js with the App Router, TypeScript, deployed on Vercel. These aren't exotic choices they're the choices of someone who evaluated tradeoffs and stopped where the tradeoffs made sense.

Vercel deserves more than a passing mention, because it changed how I iterated. Zero-ops deployment meant exactly that: git push and it's live. No servers to configure, no deployment pipeline to babysit, no Friday afternoon anxiety about what I'd broken. Every branch gets its own preview URL before anything touches production. That feature sounds minor until you experience what it does to your psychology: I stopped being precious about changes. Want to try a different layout for the hero section? Branch, build, share the preview link, decide. The cost of experimentation dropped to near zero, which meant I actually experimented.

The AI chat on this site the feature where you can ask questions and get responses briefed on my career and thinking calls the Anthropic API through a Next.js API route running as a Vercel serverless function. No backend to manage. Scales automatically. Costs nothing when idle. For a space like this, with spiky and unpredictable traffic, that economic model is exactly right. I'm not running a SaaS with predictable load curves. I'm running a thinking space that gets occasional bursts of attention. The infrastructure should match the use case, not the other way around.

There's also a Vercel MCP integration that Claude Code can talk to directly. Write something, preview it, check the deployment logs, ship without leaving the conversation. The whole loop collapsed into a single working context. That's not a minor convenience. It's a different way of working.

The site is the thesis

Here's what I find genuinely interesting about this project, and why it belongs in the Working Theses section rather than just the writing section.

The experiment and the tool are the same thing.

I built an AI-powered chat feature using AI. The chat is briefed on my career, my frameworks, my way of thinking about enterprise technology. It doesn't just answer questions it asks them back. It's designed to understand why a visitor is there before it starts responding. I built that feature by describing what I wanted to a coding collaborator that is itself an AI. The thing I made and the thing I used to make it are not separable.

That's not a clever observation about recursion. It's a signal about where software is going.

For most of the last two decades, "building software" meant either being a full stack developer or hiring one. The gap between having an idea and having a working thing was wide enough that most ideas stayed ideas. The tools that tried to close that gap no-code, low-code, template builders did so by constraining the solution space. You got something built, but it was built inside someone else's assumptions.

What I experienced with this project is different. The gap is closing, but the solution space isn't shrinking. I made genuine decisions about architecture, data flow, and user experience. I pushed back when the generated code wasn't what I wanted. I understood the tradeoffs I was accepting. The AI didn't remove my agency it removed the friction that would have slowed me down between having a judgment and acting on it.

The bigger bet embedded in this project: software is becoming personal. Not in the consumer app sense in the sense that one person, with a clear point of view and an AI as a construction partner, can now build things calibrated to a specific context rather than the average of all contexts. That's a meaningful shift, and it's moving faster than most organizations are tracking.

I've spent two decades watching enterprises struggle to absorb new technology not because the technology was bad, but because the gap between the technology's potential and the organization's capacity to use it stayed stubbornly wide. What's different now is that the gap is closing from both directions at once: AI is getting better at building, and people who think in systems are getting better at directing it.

I wanted to stand in that future rather than write about it from the sidelines. So I built the space I'm writing from. That seemed like the right place to start.