Every System Starts as a Note

ThinkingNotes did not begin as a product.

It began during my time at Trip.com, when my content team was growing to more than 20 people and I found myself repeating the same basic content SEO guidance again and again.

The guidance was important. But delivering it one person at a time was not productive. It slowed me down, and it meant the same knowledge was being distributed one conversation at a time.

The problem was not a lack of knowledge.

The knowledge was trapped inside a person.

My first attempt to make the thinking reusable

I built a simple content audit form using Streamlit and Python, then hosted it on Railway.

A user could submit a page. A page parser would extract the content and send it to the Gemini API for an audit.

But this was not a flippant request asking AI to "audit this content."

The audit contained my own thought process. It followed the criteria and guardrails I used to judge good content. The AI was not being asked to invent the method. It was being asked to apply a method I had already thought through.

That distinction mattered.

A generic request can produce a generic answer. A useful tool needs to know which inputs matter, what to look for, which standards to apply, and what a useful output should contain.

The first tool worked well. My team benefited from it, and the same basic guidance no longer had to begin with me repeating it from the start.

The tool revealed a larger possibility

Once I began building more tools like it, I started thinking beyond the individual use case.

Each tool still needed a form. It still needed the prompt and its guardrails, the connection to an AI model, and the infrastructure required to make the experience usable by someone else.

AI made building easier. It did not remove the need to rebuild that foundation.

So I asked a different question:

Why not build a tool that lets me, or anyone else, create these forms through drag and drop?

Instead of rebuilding the infrastructure every time, a user could define the inputs, add their own thought process and guardrails, and turn them into a tool other people could use.

That question became ThinkingNotes.

ThinkingNotes today: a way to wrap a carefully designed prompt inside a simple, shareable form.

A prompt is not the valuable part on its own

It is easy to look at an AI tool and think the product is simply a prompt placed behind a form.

That misses the most important part.

The value is in the thinking that has been made explicit: the questions the form asks, the inputs it requires, the instructions that remain hidden from the user, the guardrails that keep the result useful, and the structure of the output.

That was true of my original content auditor. The Gemini API could generate the response, but the audit was useful because it reflected a real content SEO process.

This is also why I do not see reusable prompts as saved blocks of text. A good prompt contains a way of approaching a problem. Once it has defined inputs, logic, constraints, and outputs, it starts to behave like a small piece of software.

A ThinkingNotes tool can ask for structured inputs while keeping the creator's underlying method consistent.

I kept building after work

I kept building ThinkingNotes for a year, through 2025 and into 2026.

I would come home tired and still build.

The product moved further from the first Streamlit form, but the original problem remained the same: how can a useful way of thinking become available without requiring the person who created it to guide every use?

The progression now looks clear when I describe it backwards.

Repeated guidance became a documented thought process.

The thought process became a prompt with guardrails.

The prompt became a tool.

The need to build more tools became a platform for creating them.

It did not feel so neat while I was inside it. It was a series of small problems, working versions, new questions, and many tired evenings.

Every system starts when the thinking leaves your head

Not every system begins as a literal note.

My first content auditor began with something I was tired of repeating. But before it could become software, I had to make my reasoning visible. I had to write down the questions, standards, decisions, and guardrails that had previously existed mainly in my head.

That is what a note represents to me.

It is the point where a thought becomes inspectable. Once it can be inspected, it can be improved. Once it can be structured, it can become repeatable. Once it becomes repeatable, it may become a workflow that other people can use.

ThinkingNotes began because I did not want to keep repeating the same basic audit guidance.

I kept building because I saw the larger possibility: a useful method should not have to disappear whenever the person who created it is not in the room.

Every system starts when someone decides that a valuable thought should not have to be recreated each time.