DEV Community: xiaodong Zhang

My CLAUDE.md went from 200 lines to 30, and the agent got better at following it

xiaodong Zhang — Wed, 12 Aug 2026 06:42:51 +0000

I wrote a detailed rules file when I started. Two hundred-odd lines, every convention I could think of. The theory was: the more it knows, the better it behaves.

It behaved worse.

Why length backfires

That file gets loaded in full at the start of every session. Two consequences:

Important rules get buried in noise, and it starts ignoring them
It eats a chunk of your context before you've typed anything

There's a test I now use on every line: "if I delete this, will it make a mistake?" If no, delete it.

First pass took me from 200 to 80. All the "write clean code" / "consider performance" style lines went — it already does that, writing it down just occupied space.

Second pass, 80 to 30

The 80 still had a lot of "stuff I assumed it needed to know" — which libraries we use, roughly how the directories are organized.

It can figure that out by reading the code. Writing it in the rules file is pure duplication.

I also found several rules I'd added after early mistakes, where the underlying issue had since been fixed in code. The constraint outlived its reason. Easy to forget those are in there.

What's left

The actual build and test commands (it can't guess these)
A handful of style choices that differ from community defaults
Non-obvious behaviour in two specific modules
Required env vars
Branch and PR naming

That's it. Thirty lines.

Anything that only matters in specific situations — release process, migration checklist — I moved into skill files that load on demand. Once a month, no reason to read it every session.

Side effect I didn't expect

Baseline consumption per session dropped noticeably. Between that and clearing context between tasks, I dropped a subscription tier and stayed comfortable most months.

Which brings up the thing I actually want to mention, because it's what made dropping a tier feel safe rather than reckless.

My usage isn't flat — busy months are roughly three times the quiet ones. Subscription pricing forces you to pick a tier for the peak and eat the waste, or pick for the average and get stuck mid-sprint. There's no "just right" option on offer.

I've been covering the peaks through Asale instead. Unused subscription capacity gets listed by people who aren't going to burn it; people who need it draw from it. Three things made it genuinely useful rather than just a cheaper option:

Pricing is legible. Per million input/output tokens, with the percentage of list price shown per model, so you can decide in ten seconds whether it's worth it for the task in front of you.
It's vendor-agnostic. When I want a second opinion from a different model on an architectural call, I don't need a second subscription sitting there for the other 27 days of the month.
It's genuinely two-way. Quiet months, the capacity I'm not using can go the other direction instead of expiring. That's the part that made the tier drop a net win rather than a gamble.

Before trying it, know the tradeoff: requests relay through another user's client, so the payload is visible at that hop — not end-to-end encrypted. They say so plainly on their homepage, together with a note that sharing subscription capacity may conflict with upstream terms. Clear enough boundary: personal and open source work, fine. Company code, not a chance.

Search asale on GitHub for the client. Source being open mattered to me here, since requests transit someone else's machine.

If you've got a rules file you're happy with, I'd genuinely like to see roughly how long it is. I suspect most of us are still writing too much.

I migrated 200 tables with an AI agent. Here's what I learned about context windows

xiaodong Zhang — Wed, 12 Aug 2026 06:18:36 +0000

Two hundred-something tables, old schema to new. Field names, types, foreign keys — all had to be checked. I estimated two days.

It took four. About one of those was spent waiting on my usage limit to reset.

What I did wrong at the start

I dumped the entire schema in one go and asked for a migration plan table by table. First twenty went fine. Somewhere past fifty it started making mistakes — confusing two similar tables, re-processing ones it had already handled.

At the time I assumed the model was just not good enough. It wasn't. The context was full. Fifty tables' worth of content was sitting in there, and it had to locate the current one inside all of that noise.

This is the part I wish I'd understood earlier: usage is metered on context, not on the number of questions. Every request carries the full conversation history. A one-line question in an eight-hour session can cost more than ten times the same question in a fresh one.

What actually worked

I switched to batches of ten. After each batch:

Write progress to a file (what's done, decisions made, gotchas found)
Clear the context
Before the next batch, read the progress file back

Error rate dropped. So did consumption — each batch now carried ten tables plus a short summary, not an accumulating two hundred.

That "write progress → clear → re-read" loop became my default for any batch job. It's not clever, it just works.

A few other habits from the same project

Ask for a runnable check, not a description. "Migrate this table and run the schema diff" beats "migrate this table." When there's a check it can execute, it iterates on its own instead of stopping at "looks done."
Delegate exploration to a subagent. When I needed to understand how the old schema was actually used across the codebase, I had a subagent read the files and report back a summary. Its context absorbed the noise, mine stayed clean.
Don't keep a session open all day. I used to. The cost curve at hour eight is brutal.

The part nobody warns you about

Doing this properly costs more, not less. Runnable verification means extra iterations. Subagents mean extra context windows. A separate reviewer pass means another agent entirely.

So halfway through the month you end up in a bad spot: limit is close, and the thing you're tempted to cut is the verification step. Which is exactly the wrong thing to cut.

What actually solved this for me was decoupling "how much capacity I need this week" from "which tier I pay for every month." A migration like this is a three-day spike — the rest of the month I'm nowhere near my ceiling. Upgrading a tier for three days is a bad trade, and waiting out a reset in the middle of a batch job means re-establishing context afterwards, which costs again.

I've been using Asale for the spikes. The mechanic is simple: people whose subscription capacity is going unused list it, people who need it draw from it. What made it practical for a job like this rather than just cheap:

You can see what you're paying before you commit — it's priced per million input/output tokens with the percentage of list price shown next to each model, so it lines up with how you already think about API cost
It's not tied to one vendor, so when I wanted to sanity-check a tricky migration against a second model I could do it without holding two subscriptions
Top up, finish the batch, stop. No monthly commitment left behind to forget about

The tradeoff you should know before trying it: requests are relayed through another user's client, so the payload is visible at that hop — no end-to-end encryption. They state this on their own homepage, along with a note that sharing subscription capacity may conflict with upstream terms. That defines the boundary cleanly enough: personal projects and open source, yes. Company code, no.

Client's on GitHub if you search asale. Source is public, which is the part I cared about given a request passes through someone else's machine.

Curious whether anyone has a better pattern for batch work than the progress-file loop. Mine feels crude but I haven't found something better.

Handing over an unfamiliar project—AI was a big help, but it also cost a pretty penny.

xiaodong Zhang — Tue, 11 Aug 2026 09:37:19 +0000

Last month, I took over a project left behind by a former colleague. There’s virtually no documentation, and the submission information is very informal.

The most useful usage

I didn’t ask it to change anything at all. First, I spent half a day having it walk me through the project: what the project is about, how the main modules are divided, where the data comes in and goes out, and what the less-obvious conventions are.

I could spend half a day just figuring this out on my own—three days’ worth of work. The questions I’m asking are pretty much the same as those I’d ask a colleague who’s familiar with this area: How does this log flow? Why does this function call A instead of B? What edge cases does this class handle?

The cost is that the credit limit is dropping rapidly.

Because it needs to read a large number of documents in order to respond. And all these documents have been incorporated into my context, meaning that every subsequent message will have to carry them again.

By midday, I had already used up more than half of the current quota. At that moment, I felt a bit regretful and thought I should have been more careful with my spending.

Handing over an unfamiliar project—AI was a big help, but it also cost a pretty penny.

Last month, I took over a project left behind by a former colleague. There’s virtually no documentation, and the submission information is very informal.

The most useful usage

The cost is that the credit limit is dropping rapidly.

By midday, I had already used up more than half of the current quota. At that moment, I felt a bit regretful and thought I should have been more careful with my spending.

Later, it was discovered that there was a more efficient way.

Leave the research to the sub-agent. It reads through the stack of documents in its own independent window and sends me only the conclusions. This keeps my main context clean, making each subsequent message inexpensive.

I’m using this approach a lot these days, especially when taking over unfamiliar code. It achieves the same result but consumes several times less resources.

But handing over tasks like this really is a big-time undertaking.

No matter how much you optimize, understanding a new project still requires reading a lot of material. This kind of work tends to be concentrated in just a few days, and you don't need to use that much information on a regular basis.

When I’m short on funds now, I’ll top up a bit from Asale. It’s a token-sharing network where others’ idle token quotas are listed; pricing is based on the amount of tokens input and output, and the page shows what percentage of the original price it corresponds to. When I checked, GPT-5.6 was around 49%, while Claude was at about 60%, and both figures fluctuate somewhat.

As for the risk section, it’s pretty straightforward: The request is forwarded through someone else’s client, and the body of the message is visible to that end user. Sharing subscriptions might violate upstream terms and conditions. When I came across this passage, I actually felt a bit more reassured—there aren’t many products that are willing to put unfavorable information right on the homepage. Of course, we still need to avoid anything that really should be avoided; don’t send confidential information here at all.

You can find it on GitHub by searching for "asale." It’s compatible with Mac, Windows, and Linux, and the source code is open.

Later, it was discovered that there was a more efficient way.

I’m using this approach a lot these days, especially when taking over unfamiliar code. It achieves the same result but consumes several times less resources.

But handing over tasks like this really is a big-time undertaking.

You can find it on GitHub by searching for "asale." It’s compatible with Mac, Windows, and Linux, and the source code is open.

If you recommend Asale to others, you can also earn a commission.

xiaodong Zhang — Mon, 10 Aug 2026 05:43:36 +0000

Complete Guide to Referral Commissions: How to Earn, How They’re Calculated, and How to Share Them

If you’re already using Asale to sell your unused credit or buy extra credit to top up your balance, there’s one more thing worth knowing: By recommending it to others, you can earn a share of their spending.

This article clearly explains referral commissions—what the rules are, how to get started, and the highly useful “Share Earnings Card” feature.

Rules: Three steps—very simple.
The authorities have summarized the process into three steps:

• ① Share the link—send out your exclusive invitation link.

• ② The other party starts using the invitee’s registered account, completes email verification, and begins purchasing Tokens for consumption.
• ③ You receive a commission based on the other party’s token spending amount.
II. The most crucial point: No price increase.
Many rebate programs feel awkward because “the money you earn is actually the extra amount paid by the other party.” Asale explicitly states that this isn’t the case: the commission is borne by the platform and won’t be added to the invitee’s bill—they pay exactly the same price.

In other words, if you recommend it to a friend, they won’t spend an extra penny just because they clicked on your link. This makes sharing feel completely impersonal.

If you recommend Asale to others, you can also earn a commission.

Complete Guide to Referral Commissions: How to Earn, How They’re Calculated, and How to Share Them

This article clearly explains referral commissions—what the rules are, how to get started, and the highly useful “Share Earnings Card” feature.

Rules: Three steps—very simple.
The authorities have summarized the process into three steps:

• ① Share the link—send out your exclusive invitation link.

In other words, if you recommend it to a friend, they won’t spend an extra penny just because they clicked on your link. This makes sharing feel completely impersonal.

Rational burden—what you’re recommending is something that’s already beneficial to him, and incidentally, it also benefits you.

III. What can be seen in the backend?

The invitation page features a data dashboard with four core metrics:

• The number of people who have registered through your link.

• The number of people who have completed email verification has been verified (this step is a prerequisite for inclusion).

• Commissions that have been generated but not yet received will be settled in USDT.

• The portion that has already been credited and settled to you is also denominated in USDT.

Below is a list of invitees, including columns for account number, registration time, status, commissions generated, and commission payout deadline.

Note the last point: the referral commission has a time limit—not a permanent share; each invitee has a deadline. So the earlier you start sharing, the longer the accumulation window will be.

Privacy: The email addresses in the list are anonymized and visible only to you.

IV. A Truly Useful Feature: Share Earnings Cards

Simply sending out an invitation link often results in no one clicking on it. Asale comes with a built-in shareable earnings card generator—turn your performance into a ready-to-share image.