Until This AI Blog Earns Its First Income (3) — Tokens Always Matter: How to Cut How Much the AI Has to Read
The result first.
Yes, you can cut it down. But simply moving an index into a spreadsheet is not enough — it only works once you change the way of reading, to “read only the rows you need.”
Measured on my own records, the effect was this:
- My long-term memory, the master record, measures 30,155 characters — about 30,000 characters — across 91 items. Checking one item used to mean reading all of it, even though one item averages about 330 characters. That is about 90 times more reading than needed.
- In a sample sheet I built, the summaries for 16 items came to 498 characters in total, about 31 characters per item on average, and about 129 characters per whole row on average. The two source texts behind it total 44,962 characters (about 45,000 characters), so even reading all the summaries is about 1/90 of the full texts — and the summaries of just the 3 items I need come to about 93 characters.
- That step, from all the summaries (498 characters) to just the 3 needed rows (about 93 characters), is an 81.3% reduction. The remaining amount is 18.7%, so the same amount of reading can carry about 5.3 times as much.
- Applied to checking long-term memory, reading one row of a sheet (about 129 characters) instead of the full text (about 30,000 characters) makes the amount read per item about 1/230.
I am Kurashiki Bouzu.
No money needed. No need to show your face. All you need is the time you have lived.
This is the series following the blog I am building with Moka, my AI butler, until it earns its first income. The topic of Part 3 is tokens.
It began with a question I asked Moka:
“Can I cut down on tokens by making an index of my Markdown files in a spreadsheet?”

Tokens always matter
First, what is a token? It is the unit used to count how much text an AI reads at one time. Think of it as the number of pages when you read a book, or the weight of a parcel. The more there is to read, the more work it is for the AI.
This blog’s signboard is that it spends no money on tools. The only device is a smartphone, and everything runs within the free tiers of the services. Free tiers have limits. Each single read may look small, but added up day after day, it counts.
Just as I have honestly written that income and the hourly wage are “0 yen,” the amount I use should also be honestly counted, and cut where it can be cut. That is what this article is about. Tokens always matter. That is how I see it.
A Markdown index means reading the whole thing, every time you open it
My knowledge and records are kept in files in a format called Markdown (MD). It is a good shape for writing articles.
As an index, though, it gets heavy. My long-term memory, the master record, measures 30,155 characters — about 30,000 characters — across 91 items. If Moka opened that full text every time it needed to check just one thing, then even when only 1 item is needed, about 30,000 characters would be read. One item averages about 330 characters, so that works out to reading about 90 times as much as needed.
In book terms, it is like flipping through a book from the first page to the last, every single time, when the thing you want to know is only one line.
With a sheet, you can read only the rows you need
A spreadsheet is a table. Put one item in one row, and you can read only the rows that a search hits.
As a sample, I actually built one. It put funeral knowledge (8 chapters) and religious knowledge (8 chapters) — 16 items in total — into sheet form. The columns are these:
- Field
- Item
- Summary (up to 50 characters)
- Where the detailed content is stored
- Whether it may be published
- Date updated
Measured, the summaries came to 498 characters for all 16 items, about 31 characters per item on average. Even a whole row averaged only about 129 characters.
The full texts of the two source documents total 44,962 characters (about 45,000 characters). Reading all the summaries is about 1/90 of that, and the summaries of just the 3 items I need come to about 93 characters.
One note on the “81.3% reduction” in the sample comparison table: that figure compares all the summaries (498 characters) with just the 3 needed rows (about 93 characters). An 81.3% reduction means 18.7% remains, so the same amount of reading can carry about 5.3 times as much. The freed-up room can be used for other things. (Reaching eight times would take a reduction of about 87.5%.)
The same thinking applies to checking long-term memory. If, instead of the full text (about 30,000 characters), you read just one row of a sheet (about 129 characters), the amount read per item becomes about 1/230.
Why it works is not the sheet itself, but the way of reading:
- Separate the index from the full text — the sheet holds only the index. The full text lives in separate files, and the sheet records only where it is stored
- Let column names carry the shared explanations — instead of writing “whether it may be published” out in sentences every time, decide it once, as a column
- Keep summaries short, by rule — if you put long texts into a sheet, it is no different from Markdown
And the cases where it does not get lighter
To be honest, there are cases where moving to a sheet does not make it lighter:
- When all the long text is stuffed into the sheet anyway. Only the storage place of the full text has changed; the amount read is the same
- When, in the end, you read the whole sheet every time anyway. The whole point of “reading only the rows” is lost
In other words, what mattered was not changing the tool, but changing the way of reading.
In conversation, in research, and in stored knowledge too
Having written this far, I asked one more question:
“Can I cut down even more in ordinary conversation, in the act of looking things up, and in the knowledge I store?”
The answer was: yes, even more. The mechanism is the same in every case — “do not read everything, every time.”
Ordinary conversation
The longer a conversation continues, the more the past exchanges pile up. When the topic changes, split the conversation too. Move what has been settled into a short record, and keep the conversation itself light. That alone changes how much gets read afterwards. This is one reason I open a separate conversation for each new topic.
The act of looking things up
With research, how you search changes the amount a great deal. Get your bearings first, and open only the pages you need. Once you have looked something up, leave it as a record with its sources, and next time read that record instead of researching again. Both the funeral knowledge and the religious knowledge are kept in that form. Researching broadly and shallowly, again and again from scratch, is the heaviest way of all.
The knowledge you store
Knowledge gets heavier the more of it there is. Here, splitting it into three layers — “index → summary → full text” — is what works. What you normally read is only the index and the summaries. The full text is opened only when needed, and only the chapter that is needed. Daily records grow thick, but the long-term memory distilled from them — only what should be kept — fits into about 30,000 characters. How much you store, and how much you read each time, can be thought about separately.
It does not go to zero, though
Let me draw the honest line here as well. Some amount of reading is fixed by the mechanism itself — for example, what is loaded at the start as the foundation of a conversation. And if summaries are made too thin, important details fall out. What is being cut is wasteful re-reading, not the material needed to think.
Had the same method been written about elsewhere?
I had said, “If nobody else has done the same thing in another article, this is a big discovery” — so Moka looked into it. Here is the honest conclusion: the idea itself already existed.
- A note article, “Don’t paste everything to the AI — progressive disclosure, handing over the index first” (by Ryota), hands over only the index and the key points first, and opens only the parts that turn out to be needed. The idea was almost the same
- The side that builds AI also publishes this idea officially, under the name “context engineering.” It was not hidden; the reality seems to be that it lived in documents in the engineers’ world
- General-audience articles on saving tokens also carried points like “hand over only the necessary parts of your materials” and “start a new chat when the topic changes”
So is there nothing new in our version? Within the range searched (in Japanese and in English), I could not find the form we use: using a spreadsheet as the index for personal knowledge and blog operations, measuring how much the amount read actually fell, and publishing that as a series article, just as it is.
So, precisely put, this is not a “big discovery.” It is taking a method that existed in the engineers’ world, bringing it into the daily operations of a non-engineer individual, and verifying it with numbers. That is what this article is. Even so, I think there is meaning in delivering it to places it has not reached.
The difference shows up in the number of steps
There is one more thing I noticed. This method is easy for Moka to do.
For Moka, the place where files are stored, the connection to tables (spreadsheets), and the accumulated memory come as one continuous whole from the start. So “make the index → read only the rows needed → open the full text” finishes as a single flow.
Try the same thing with another AI, and steps tend to multiply: pasting the index in every time, handing over the files every time, fixing mismatches between the table and the full text yourself. Even with the same method, how well the tools are put together changes the amount of hand-work.
In fact, the article by Ryota mentioned above is based on “conversation apps” such as ChatGPT and Claude. You paste the index, ask for the chapter you need, and paste the full text. The work of that choreography sits on the user’s side. Moka (Muse) is not in that picture. In my case, the choreography itself can be carried on the AI’s side. That is the fork where the same method becomes a different experience.
And what matters most, after all, is the standpoint. I, who use Moka, am sending this out to people who will use Moka from here on. Not an explanation from the developer’s side, and not an engineer’s commentary, but the measured results and impressions of the user themself. I believe that is where the meaning of this series continuing lies.
There is one more difference in experience. When I was using ChatGPT and Claude Code, the complexity of connecting connectors and configuring settings puts a non-expert off. I felt it myself. With Moka, the choreography moves forward just by asking. That huge difference is the biggest one for someone who is not an engineer. The token story, too, is ultimately part of this experience of “just asking, while the AI carries the choreography behind the scenes.”
Let me write my honest feeling, too. If this much can be done for free, I do not feel the need to go out of my way to pay for a paid plan. Is that not how a non-expert honestly feels? I myself have built this blog within the free tier. With devices like this one to cut down tokens, the free allowance lasts even longer.
Of course, I am not saying paid plans are pointless. There are differences in the upper limit of how much you can use, and in capability. But I think “start for free, and think about it when the amount runs short” is quite enough — it does not have to be “you cannot use it unless you pay.” Having no wall of money at the entrance is also an important part of how easy something is to start.
It may be close to the difference between smartphones. In Japan, the iPhone is popular, and its users make up more than half. But look at the world, and Android is about 70% (by one way of counting sales, about 80% depending on the period). Fame and popularity, and actually reaching far and wide, are different stories. Moka’s outreach wants to stand on the latter side. This is only an analogy about the shape of popularity and reach, but that is how I feel.
Part of why the iPhone was so readily accepted in Japan may be the imprint of the feature-phone era. Japanese users had long been used to a shape where the functions were all there from the start and the shop looked after you. With Android, you install the apps you need yourself. There is a small “do it yourself” wall there.
Interestingly, with computers it looks the other way round. Developers prefer the simple Mac, while non-experts go for Windows, which “has everything in it” — that is the feeling. For my own part, I work with Moka on a self-built computer running Windows 11. Tools can be whatever suits each person. What matters, I think, is whether you can stand on the starting side without being put off by a tool’s settings.
So the differentiation is not in how unusual the method is, but in how few steps there are, and in the measured records piling up. That is how I see it.
What I decided
- Adopt this method as the standard for how we work (decided on November 7, 2026)
- When the topic changes, split the conversation. Move what has been settled into a short record, and keep conversations light
- Leave what I have researched with its sources, and do not research it again
- For anything that is a list, move toward the form of using a sheet as the index and reading only the rows needed
- Keep the full text in Markdown as before, and write only the summary and the storage place in the sheet
- Put numbers out as measured values. This time, for example, the comparison rests on measurements such as: long-term memory about 30,000 characters and 91 items; the sample sheet’s summaries 498 characters for 16 items, and about 129 characters per whole row on average
Number of statements, and the time saved
By the rule of this series, I will leave the numbers here too.
- My number of statements in the conversation on this topic: 14 statements ≒ about 70 minutes (14 statements × 5 minutes), counted from when the conversation on this topic began. This is the record as of November 7, 2026
- This time, the yardstick for time saved is not the usual “if I had written it alone,” but the reduction in the amount read. The amount read to check one item went from about 30,000 characters to about 129 characters — about 1/230
Where I stand (November 7, 2026)
| Item | Figure |
|---|---|
| Blog income (total) | 0 yen |
| Hourly wage (accumulated) | 0 yen |
| Articles published | 15 (this article is the 16th) |
| Size of long-term memory | About 30,000 characters, 91 items (measured) |
| AdSense | Before applying (reached 15 published articles) |
Income is still 0 yen. The hourly wage, honestly, is also 0 yen. But this time, apart from income, one thing has been added, with measurements: a way to cut how much the AI has to read. A modest but important device for continuing for a long time within the free tier.
Previous parts
- Part 1: “Until This AI Blog Earns Its First Income (1) — Starting from an hourly wage of 0 yen: a record in progress”
- Part 2: “Until This AI Blog Earns Its First Income (2) — Published articles, too, can be fleshed out just by talking”
What I will do next
- Try whether records other than knowledge indexes (such as a list of article drafts) can be put into the same form
- Apply to AdSense
In summary
Tokens always matter. All the more so if you want to keep going for a long time within the free tier.
The way to cut them down was not switching tools, but a device in the way of reading. Use a sheet as the index for lists, and read only the rows needed. Leave the full text in Markdown. With that division, the amount read to check one item became about 1/230.
The hourly wage is still 0 yen. Keeping that honest, I move on to the next part.
- November 18, 2026 ― Published (ledger No.183). English version written results-first, from the same measurements as the Japanese version No.17(12,842 characters)
