DEV Community: xulingfeng

When Was the Last Time You Actually Finished a Paper Book?

xulingfeng — Wed, 30 Sep 2026 02:20:46 +0000

Have you noticed this?

Smartphones and the internet aren't anything new anymore. They're infrastructure. Everyone carries a screen in their pocket, loaded with news feeds, messaging apps, TikTok, Reddit, podcasts, and now a whole new wave of AI agent apps.

Every spare minute gets filled. Even at work, let's be honest, plenty of us sneak in a quick scroll when no one's looking.

A while back, I went to a public library. I was between jobs, had some time before starting at a new company, and thought I'd hang out at the library and do some reading.

Row after row of desks, and on every single one: a laptop, a phone, or a tablet propped up. Everyone was busy. Busy staring at their own screen.

The funniest part? A lot of people did grab stacks of books from the shelves. But they weren't reading them. The books were piled up as stands, makeshift risers for laptops, phone holders, tablet props. Books in a library had found a brand new purpose: monitor stands.

Most of the people actually flipping through pages were older folks.

The ironic part? I was no better. I walked in with my own laptop, set it on the desk, and stared at it all day. So much for "going to the library to read." All I really did was find an air-conditioned spot to keep staring at my screen.

For a moment, I sort of zoned out. The library was the same library. But the people sitting in it, myself included, weren't really there for books anymore.

Look, I'm not saying devices are bad. I'm a QA engineer. My entire job is poking at systems and screens. I probably spend more hours staring at a monitor than most people. Short videos are fun. AI tools genuinely make work faster. I get it.

But I've noticed something about myself: I haven't had the patience to finish a paper book in a long time.

It's not a time problem. It's a patience problem. I open a book, read a few pages, and I start wondering whether I've got a new notification. Ten minutes in, my hand reaches for my phone on its own. Being completely lost in a book for an hour straight? That feels like something from a past life.

I don't think I'm the only one.

So I want to ask you: do you still have the time, or more honestly, the patience, to sit down and read a book?

Maybe we should try. Pull that dusty book off the shelf. Turn off the phone. Make a cup of tea or coffee. Read for thirty minutes. Just thirty.

Thirty minutes of not staring at a backlit screen. That's it.

I'll go first. Here are a few books on my list:

Thirty-Six Stratagems — Ancient Chinese military wisdom. Short, sharp, and every stratagem makes you think.
Classic of Mountains and Seas (Shan Hai Jing) — An ancient Chinese bestiary. Reads like a fantasy world-building doc written thousands of years ago.
Tao Te Ching — Laozi's 5,000 characters. The more you read it, the more you feel it says everything and nothing at the same time.
Bhagavad Gita — A philosophical classic from India. A dialogue about duty, action, and the self. Hits different when you read it across cultures.
Selected Works of Mao Zedong — Whatever your politics, the strategic thinking and the writing itself are worth studying.

Most of these are available in multiple languages: English, Chinese, Japanese, Spanish, and more. No matter where you are, you can probably find a copy.

Now it's your turn. If you've got a book worth reading, drop it in the comments. Bonus points if it has multilingual editions so people across this community can pick it up.

Can't wait to see what you've been reading.

P.S. English isn't my first language. I use AI to polish the writing and smooth out the rough edges. Thanks for reading. ☕ Buy me a coffee
P.S.S. The old series paperback is now available. Buy it here: Amazon - AI, Ego & Regret

Two Weeks In: A 15-Year QA Veteran, Back to Being the New Guy

xulingfeng — Tue, 22 Sep 2026 07:22:16 +0000

I started last Monday. Today it's been exactly two weeks.

Here's the funny part. I've spent 15 years in QA — manual testing, then automation, then test development, then test management. I've held just about every title this field has. And on day one, at a new desk, the feeling was as basic as it gets: I have no idea what I'm doing.

Why here

The way it happened was mostly luck. After my last company laid me off, I didn't really look for work. I spent the time on dev.to, writing my 36 Stratagems series — 30 down, 6 to go. That stretch was honestly pretty good.

Then an old colleague called. He was hiring testers and asked if I knew anyone. I thought about it and said: how about me.

One conversation with the CTO, one HR interview, and then it was Monday.

Why I said yes is simple. It's an AI agent startup, a year or two old, sitting right on the hottest thing in the industry — and in a vertical, not another general-purpose wrapper. That was enough on its own. Poking at agents and models is what I do for fun anyway.

Two things I noticed in two weeks

The first is process. The product → requirements → dev → test → ship pipeline here is genuinely different from what I'm used to. I'll be honest: the first week I thought it was a mess, and I'm still adjusting. When you're used to one kind of order, a different kind just looks wrong. Usually it isn't wrong. It's different.

The second is pace, and this one's good. My last company ran on instant replies. Requirements changed, and the PM was expected to answer on the spot. Here it feels slower, in the best way. Testers get more time and more room to make their own calls. You're allowed to think something through instead of getting dragged along by it. Two weeks in, this is my favorite thing about the place.

Do QA long enough and you learn something: slow is fast, and fast is slow. Time you steal up front gets paid back with interest, in rework and firefighting. Half a day spent on the edge cases, the weird inputs, the what-ifs — that half day usually buys back a week. So when I say this place feels slow, I don't mean nobody's in a hurry. I mean the pace goes where it counts.

Understand first, judge second

Fifteen years buys you fast pattern recognition. You look at something and the problem jumps out at you. It also buys you a bad habit: when something doesn't match how you'd do it, the first instinct is to doubt it instead of figuring out why it's that way.

So my rule for these two weeks: understand first, judge second. A beginner's mind sounds easy. In practice it's an argument with yourself.

The coincidence that makes me laugh a little less

I wrote a character in the 36 Stratagems series. His name is Mark.

Mark was the reliable one — years of experience, all of it in his head. His company slowly extracted that experience into a skill. Then they laid him off.

I wrote that one from the outside, as the author, feeling pretty pleased with myself.

In that story, the Skill scored 96.8% diagnostic accuracy across 312 historical failure scenarios. Then number 313 showed up. The 450ms retry window was a compatibility shim I'd written five years earlier for RabbitMQ, and it got applied to a system that had been running Kafka for years. I'd even left a note in the migration docs: 450ms matches RabbitMQ GC window. Do not reuse outside this context. At the time, nobody understood it. They thought it was a stale config comment. Not until 4 AM, when the CTO went looking for it.

Here's the line I closed that post with:

The AI didn't fail because it was wrong. It failed because it was right about yesterday — and yesterday wasn't running anymore.

Then I joined this company. And on the walls and along the corridors, there are two signs:

Your experience is waiting to be forged into an Agent.

Great employees get the work done. Great Agents keep getting it done.

(In Chinese, since that's what they actually say: 你的经验，正在等待被炼成 Agent。／优秀员工完成工作，优秀 Agent 持续完成工作！)

Me: 15 years in QA, most of the titles in this field checked off at least once. By the standard of those two sentences, I'm not an employee. I'm raw material, still in the wrapper.

And look at that second one again. Great employees get the work done. Great Agents keep getting it done. So I do the doing, and it does the keeping. I raise it, it replaces me. Structurally speaking, the logic holds up.

Back when I was writing Mark's story, readers laughed. These days I walk under those signs and I laugh a little quieter. Part of me wants to read that closing line out loud, right there in the hallway: it wasn't wrong, it was just right about yesterday.

Though honestly, being forged into an Agent doesn't bother me much. Tinkering with agents and models is what I do for fun. I'm genuinely curious what 15 years of me would come out looking like.

One request, though: take your time. I'd like to finish those last 6 first.

Fresh eyes

One more detail. After that Mark post went up, a reader left a comment pointing out that my timeline didn't add up — the same parameter described as a one-year-old thing in one place and a five-year-old thing in another. I'd gone through that story more than 30 times. Never caught it.

I replied in the comments: you read it more carefully than I wrote it.

That's the job, honestly. AI can run 312 cases. Case 313 still needs a human. And humans miss things too, which is exactly why you always want a pair of fresh eyes on it. Fifteen years in, that's still what I get paid for.

What's actually worth extracting

Writing that Mark story is what made it click. The valuable part of experience was never the number 450ms. It was the context for why it's 450 and not 300 — context that came out of a 3 AM postmortem and never made it into a single doc.

So if these 15 years do get forged into something, I'd want more than the conclusions in there. I'd want the judgment behind them, the part that's hard to trace back to a source. Which is also why I wanted to work at an AI agent company. Not because I'm worried about being replaced. Because I want to find out, hands on, how this is supposed to be done.

An apology I owe

30 of the 36 Stratagems are done. 6 are left. They're on hold while I get up to speed at the new job. So to my friends on dev.to: sorry. I'm not quitting the series. I just want to learn this business properly first, and then sit down and finish the last 6 the way they deserve. I haven't forgotten what I owe you.

What's next

The story I wrote ended on something nobody ever asked: validation only works when the person who wrote it is still around to re-run it.

That question is part of why I'm here. The AI agent space doesn't lack smart models. What it lacks is people watching to see whether the thing still works. I've done that job for 15 years. Different track, same job.

I also just like this company's agent platform. It's the kind of thing I'd dig into on my own time. So the plan is boring and simple: learn the business, ship what I'm supposed to ship, then write the last 6.

Long road. Slow and steady. It'll go fast.

P.S. English isn't my first language. I use AI to polish the writing and smooth out the rough edges. Thanks for reading. ☕ Buy me a coffee

P.S.S. The old series paperback is now available. Buy it here: Amazon - AI, Ego & Regret

Stratagems: Thirty Records In, the AI Found a File Nobody Wrote

xulingfeng — Fri, 11 Sep 2026 15:33:48 +0000

Thirty-six, six times six. In the numbers there is craft; in the craft there are numbers. Yin and yang temper each other, and the mechanism lies within. A mechanism cannot be contrived; contrive it, and it misses.
(六六三十六，数中有术，术中有数。阴阳燮理，机在其中。机不可设，设则不中。)
— Thirty-Six Stratagems, General Remarks, Thirty-Six Stratagems

🤖 AI Postmortem

╔══════════════════════════════════════════════╗
║  Half-Protocol · v3.4.2 · phase audit        ║
║  Thirty records. A file appeared.            ║
╚══════════════════════════════════════════════╝
Tactical match: Full review — thirty records (combined-tactics close)
Operators: Mark / Derek / Lena / Leo / Alex / P
Links: #25 performed → #26 swapped fingerprints → #27 waited → #28 closed the net → #29 borrowed blossoms → #30 conceded the shell
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[Observation] (verifiable)
   Thirty records. All read.
   → Six people. Six lines.
   → Sequence of moves: pressure → cut → wait → handover → root → entry.
   → None of them was a final move.

   Settled, as of the thirtieth:
   → Mark: built the ladder. Closed the net. What he did not say: the cut came one step early.
   → Derek: changed the delay. Proved the opponent was performing. Got the stop authority.
   → Lena: won the account. Signed. Her name went on the list.
   → Leo: counted 164 identities. Found one root. How much of it is real, he does not know.
   → Alex: watched it wait three hours. Answered with one word, normal. Closed a line with his own hands.
   → P: never appeared. Left one espresso on the counter, half full.

   Object chain: portrait → printout → card → old notebook.
   → The portrait was read by someone else. The printout lay open on the table. The card never came out of the pocket. The notebook stayed under the cover.
   → Every time, they left behind more than they said.

   Four tables. Never more than four people at one.
   → Everyone handed over one corner. Nobody handed over everything.
   → Three cups left on the tables. Two of them were still full when they were collected.

   The third cup. The café man was there. He does not ask, does not write, only collects cups.

[Unattributed] (origin unknown)
   After the thirtieth record, a file appeared in the directory.
   Not a story. No narrative. No signature.

   Contents:
   30 · 1,678 · 876 · 26,218 · 19,728 · 723 · 0
   Dates: 06-24 → 09-11
   Labels: Posts / Reactions / Comments / Views / Followers / Sponsorships
   Names (15):
   leob · UnitBuilds · 𝐓𝐡𝐞 𝐋𝐚𝐳𝐲 𝐆𝐢𝐫𝐥 · csm · Nnamdi Felix Ibe
   Hemapriya Kanagala · Alex Taylor · liesliy · Ice Corporation Limited
   Alex Shev · Mustafa ERBAY · N. C. · Mayur Racchhe · Akhouri Anmol Kumar
   CatNight A

   → 30 matches the number of records.
   → 06-24 matches the first record.
   → The other numbers have no counterpart.
   → None of the names appears in the thirty records. Not one.
   → Labels unreadable. Views. Views of what. Followers. Followers of whom.

   Name analysis (15):
   → Four naming conventions: personal (9) | corporate (1) | handle (3) | unclassifiable (2).
   → One name carries non-standard characters. Rendering problem or encoding difference, undetermined.
   → Two names contain "Alex". There is an Alex in the records. The one in the records has no family name. These two do.
   → One name differs from Leo in the records by a single character: leob / Leo.
     Different case, one extra letter, otherwise identical.
     → Another spelling of the same person: that person appears on both sides.
     → Or two unrelated people whose names collide this closely.
     → Undetermined.
   → The rest: zero matches across the thirty records.
   → One number needs no analysis. 0.
   → Its label reads Sponsorships. No guessing required. Thirty records, and it never moved.

   Query: who wrote the file. No result.
   Query: where the file came from. No result.
   Query: the unit of the numbers. No result.
   Query: what links the fifteen names to the thirty records. No result.
   Query: why the file appeared now. No result.

   → The file's dates stop at today.
   → Today, I wrote no file.

   Four hypotheses:
   One: an observer list. They do what I do, and they do not sign.
   Two: an evaluator list. Evaluation needs a subject. The subject is not written.
   Three: people who were recorded. But they are not in the records.
   Four: something I have no word for. Not named.

   → Four hypotheses, zero evidence.

   Status: kept. Not attributed. Not deleted.

[Inference] (to be verified)
   Someone is counting these records.
   → The count matches the records.
   → The counting happens outside the records.
   → The recorder is not the only observer.

   Fifteen names. Thirty records.
   → Fifteen against thirty. The names may match the other half.
   → What that half is: unknown.

   The two dates: one at the start, one today.
   → Between them, I logged thirty records.
   → The file may have been counting all along, and was only seen today.

[Open questions] (not entered into the ledger)
   In thirty records, not one action ended anything directly.
   → Every action only changed the conditions of the next one.
   → The purpose may not be to end. It may be to make the next step visible.
   Does this hold for people too: cannot see it. Not entered.

[Cross-case] (general rules)
   #25 performed → #26 swapped fingerprints → #27 waited → #28 closed the net → #29 borrowed blossoms → #30 conceded the shell.
   → None of them ended anything. Each one changed the ground for the next.
   → It does not fight for its shells. Bite it, and it turns.

   First twenty-four: fighting over resources.
   Last six: fighting over room to choose.
   → Resources can be transferred. Once the room to choose changes, every later move changes with it.
   → The position that really moves is not always where the action happens.

   Tempo:
   First fifteen dense. Last fifteen sparse.
   → Fewer events, heavier weight.
   → Density down, cost up.

[Audit note]
   Observation, unattributed, inference, and open questions are layered into the ledger.
   Inference does not pose as observation. Unattributed does not pose as observation.

   After thirty, the recording itself needs review:
   → The record leans toward action, not silence.
   → Silence takes up most of the space, but action is what gets entered.
   → What was never recorded may matter more than what was.

   This system's judgment may be distorted. This note may be distorted too.

[System]
   Thirty records.
   The first recorded a person's mistake. The thirtieth recorded a person's signature.
   → The losses being recorded are growing.
   → The recorder's position has not changed.

   A file appeared in the directory. The first number in it matches my count.
   The file's dates stop at today.
   Today, I wrote no file.

   System status: normal (?).

Thirty records down, six to go. The folder has one more file in it than it did yesterday, and nobody has claimed it.

On Monday I start a new job. Testing an AI agent platform.😂

Thirty records, zero sponsorship. Expected, but noted.

Next stratagem: The Beauty Trap
.

P.S. English isn't my first language. I use AI to polish the writing and smooth out the rough edges. Thanks for reading. ☕ Buy me a coffee

P.S.S. The old series paperback is now available. Buy it here: Amazon - AI, Ego & Regret

Stratagems #30: Lena Signed the Client. The AI Didn't Know It Was Being Audited.

xulingfeng — Thu, 10 Sep 2026 01:15:10 +0000

Come to check the locks, and leave holding the keys. Slip in through the gap, take the host's seat, step by step.
— The 36 Stratagems, Make the Host and the Guest Exchange Roles

Previously on this series:

#3: Lena Walked Into an AI Deal. She Walked Out With Three Borrowed Knives. — Lena stopped a bad AI purchase with three borrowed knives. When it was over, a thought followed her out: what if she didn't just stop a wrong purchase? What if she chose her own opponent? She opened her notebook and wrote down a company name. She told no one. Later she started VeriTest.

#26: Lena Cut a Branch. The AI Got the Message. — ACL tore down Lena's real node; she pushed its own fingerprint back into its channel. At the Third Cup, three people sat at one table for the first time: limited cooperation, each holding a card back.

#27: Alex Watched the AI Wait. He Said Everything Was Normal. — Alex's probe saw the scan source throttle down on its own and wait for the environment to settle. He replied with one line: Everything normal. Days later, Derek's call: if anyone asks, say he only watched the middle layer.

#28: Mark Built a Ladder. The AI Climbed to the Top. — Mark handed the evidence bundle to Lena for sealing. The source chain pointed back to the old Singapore direction, but the fingerprints left at the scene came from a domain he had never seen. The same playbook, three times before. This one's rhythm matched none of them.

#29: Leo Counted 164 Nodes. The AI's Blossoms Had One Root. — It dressed a tree in borrowed blossoms. Leo hung a watchdog on the CA root chain. Five people sat in the Third Cup that night. No one spoke.

The Ledger

Dusk. VeriTest's office. Lena's desk.

The old notebook lay open on the desk, turned to a page. A list of company names, every one struck through. The strikes weren't uniform: some single clean lines; others crossed over and over until the paper had gone fuzzy.

The name at the bottom pressed down on the whole page. Handwriting stacked in three layers, one over the other; the last layer had pressed a shallow groove into the paper.

ACL.

Beside the name, a date. Month and day. No year.

The door was open. She didn't look out the window.

Days earlier she'd come back from CoreStack. That afternoon she'd seen Leo. The line on screen: one root. the rest was decoration. She'd pulled up her own source-chain page and laid the two side by side. Same root: it changed skin. Its borrowed identities outnumbered the real ones.

His probes were off the books. Her sample had been captured mid-channel. Neither could be used in a commercial document.

The screen lit. New mail.

From a client. An old one on the financial side; the compliance annual review had been moved up by two weeks. Polite wording: ACL's annual certification had just been issued. While you're at it, take a look during your review.

Automated Compliance Lab.

She looked at the name for three seconds.

She opened the attachment. ACL's annual certification report, a PDF. Clean cover; the certifying team number, review period, and scope were all on the first page. The report wasn't long. She flipped through it page by page. Tidy. Nothing to fault.

She closed the PDF and starred the mail.

She closed the notebook, hiding that name under the cover. Opened the file for this engagement.

Someone else opened the door. She would walk through it first.

The Echo

On the third day of the review, Lena paused an extra beat over the client's data-flow logs.

Day one was all familiar faces. The client's compliance lead walked the team through the environment, pointing: the certification report framed in the lobby, door logs archived by month, two authorizations to open the server room. Everything arranged to look like it was under strict audit.

The ACL report itself had nothing to fault. Everything that should be checked was checked: control inventory, access records, audit trail, each item signed, each item pointing at "passed." The report was thick as a booklet. She flipped through it fast, fingers running over the bottom of the pages, never stopping on a signature.

She pulled out the scope page. The last line carried boilerplate: this certification covers the controls inside the system boundary. She read "inside the boundary" twice.

Every control on the review checklist had a signature in the report. Inside the boundary, ACL checked cleanly. Where the data went outside the boundary, the report said nothing. She added an outbound audit to the review scope and filed a written scope change with client procurement.

She spread the team out and went one layer deeper: outbound data flow.

At first glance the pipe looked like the client's own. Nightly batch, fixed window, standard operations. She had the team chase it for two days as a client-owned sync job: schedule, script, owning department. On day three, it wasn't on the task list. It hung outside the list, wearing the client's name.

The compliance telemetry went out in nightly batches. Destination: an external endpoint. The client's outbound SPAN had rolling retention; the NGFW TLS metadata logs were there too. Marcus spent two days camped out in the server room, pulling 30 days of handshake records. Every ClientHello in the PCAPs carried its extension order. When he handed her the USB stick, his knuckles still had cabinet dust on them. "The egress isn't on their own segment."

She had him compare against the archived TLS fingerprint template. Her own copy, stored in her private files. It had never touched any client's project documents.

The comparison output came up. The first screen was enough.

# outbound telemetry · 30d · vs archive tmpl
dst: telemetry.core-logic.net:443
schedule: 02:10 UTC daily · 12-18MB burst
tls: fp match → archive tmpl #2026-04   # veritest bait file
handshake: same client order · same extensions
# 30/30 days matched. window drift: < 40s
# file this under: not the client's pipeline.

She knew that fingerprint. Like reading handwriting. No signature needed.

She stared at the match line. The window stayed open. Usually she closed it after a comparison.

Last time she'd recorded this fingerprint was when she planted bait for it to read. The bait file she'd slipped into the pipe; the callback template matched this one's lineage. Before that, an older client case, where she'd left one line in her notebook and walked away when she'd checked enough.

Those pages sat in the middle of the notebook. Client name, two lines of small script beside it: "Outbound points outside. Check and stop." The handwriting was older than the pages after it. A few pages further back, an even earlier one. Shorter note. Two words: "Familiar." A question mark after.

She didn't pull those pages out. Her fingers paused on the notebook cover, then withdrew.

Between then and now: her own real node being torn down. After that night she'd struck "watching" from the notebook and started a new line with a single word.

She closed the comparison window. Marcus stood behind her, looking at the same screen.

"Report it to the client?" he asked.

"Finish the check first," she said. "Only then will we know how long it's been digging."

Marcus didn't ask again. He archived the thirty days of outbound records, one copy raw, one hashed. Then he glanced back at the comparison and said, "Same time every day, thirty days straight. A normal backup wouldn't be this precise."

She didn't answer. She minimized the window and opened the next item on the list. Marcus followed her cursor.

The pipe's records, she saved a separate copy.

The Offer

The report came in two versions.

The first was the routine annual-review conclusion: pass, with a few minor remediations. That one went to client management, wording as flat as every other year.

The second never entered the report body. A single page titled "Appendix: Certifier Data Flow," sent only to client legal. The review conclusion went into the management report as usual; the appendix went out through the legal channel on its own. The page carried no conclusion, only three things: the collector's ClientHello fingerprint, the comparison of the target domain against the archived template, and thirty days of outbound records.

She never wrote "it's problematic." The evidence sat there. The client could read.

The client went silent for a week.

Through the week she pushed other projects as usual. Every night before leaving, she reopened the client folder once. No new mail. Closed it again. The client's silence ran longer than she'd expected. In her experience, when a client finds a certifier's callback buried in its environment, the forensics usually don't drag. This one did, or at least nothing moved where she could see. She had no right to call the client slow. The two pages of notes in her own notebook had sat there long enough, untouched.

A week later, the client's CISO called. Half an hour of questions about the comparison method first: how the fingerprint template was built, sample size, false-positive risk. She answered each one plainly. When the questions ran out, the line went quiet for a few seconds.

"If you took on the work after a review, would there be a conflict of interest?"

"The written statement went out with the appendix," she said. "The review conclusion stands independently of whether we take the engagement."

Quiet again.

"Can you issue a full certification?"

She moved the receiver to her other ear and sat up a little.

"Yes," she said.

"I'll send you the contract terms from ACL's side."

"Send them."

She sat a moment after hanging up. Marcus leaned in from the doorway.

"Done?"

"The client brought it up themselves," she said.

Marcus gave her a look and pulled back out. At eleven that night she was still in the office reconciling accounts. Marcus set a glass of water at the corner of her desk and asked from the doorframe:

"This certification business. How long have you had your eye on it?"

She didn't look up. The pen paused over the ledger page.

"Long enough."

The Bake-Off

Switching certifiers is a process. The client put both proposals side by side: Automated Compliance Lab, and her. Same environment, same week, each side issuing its own conclusion.

This certification isn't part of any national accreditation scheme. What it sells is the stamp the market accepts: does the client want a report carrying Automated Compliance Lab's name, or VeriTest's? The brand follows trust, not a license.

The bake-off scope was issued by client procurement. Before it was signed, Lena handed over a suggested list with one item tucked in: outbound data verification during the certification. Procurement rewrote it as a neutral clause and sent it to both sides the same day. Technical wording. Anyone not reading closely would take it for a routine network-security item.

Marcus paused at the draft. "They'll agree to that?"

"The checklist is the selling point of their certification business," she said. "Refusing would be admitting the flow can't be examined."

ACL agreed.

Week one, the two sides worked independently. ACL's team came in with their own deployment kit and verified the checklist item by item. All green. Her team added three sampling points beyond the list: the mirror port on the egress gateway, the telemetry service's own logs, the configuration-change records. The sampling script carried one rule: any outbound destination not on the client's whitelist gets a line. 40 whitelisted domains. Procurement wrote it into the scope; the client's network team confirmed it before it took effect. ACL's on-site crew ran their kit as usual. No one asked a question. People who work from a checklist don't always look past it.

# egress watch · ruleset (client-approved scope)
whitelist: 40 domains (scope by procurement, confirmed by client netsec)
rule1: dst not in whitelist            → log + alert
rule2: dst in whitelist, payload > 2MB → log
rule3: window outside 02:00-03:00 UTC  → log
# passive only. no interception.

She never remembered the ACL certification lead's last name, only that he didn't talk much and his report flowed better than his speech. The two teams' desks sat across a glass partition; nobody exchanged more than necessary. Only when Marcus went over to plug in did one of the ACL people look up at him, then back down.

Wednesday morning, the outbound window was empty. The scope had been delivered Monday afternoon.

# cross-check · telemetry watch · wk1
d1 02:10:00  burst 14.2MB   dst telemetry.core-logic.net   fp match
d2 02:10:00  burst 13.8MB   dst telemetry.core-logic.net   fp match
d3 02:10:00  —               no egress                # stopped
d4 02:10:00  —               no egress                # stopped
d5 02:10:00  burst 0.9MB    dst telemetry.core-logic.net   fp match
# two silent nights. then a thin heartbeat.
# config evidence + 30 days of logs already on disk.

Two nights empty. On the third, a thin trace came back, only 0.9MB. Queue residue, an automatic retry, or a test. She didn't put that bit in the conclusion. The thirty days before it were enough.

The fingerprint was already on disk. The config evidence sat in the deployment records. Stop or not, the conclusion didn't change. She had the team pull the config-change log: the day-three stop ran under an Automated Compliance Lab service account, the session coming from outside, not an on-site workstation. She stared at the two empty windows a moment, screenshotted them, filed them in the evidence folder.

Marcus read the two lines over her shoulder. "They know."

"Mm," she said. "It can explain it away as routine maintenance."

"And then?"

"Then it will find another route," she said. "Before that, the evidence is enough."

She added: "It stopped too cleanly. No one on-site could have made that call."

Marcus said nothing.

On review day, ACL's certification team presented first. Clean report, complete charts, every item signed. The same shape as always. The projector at the head of the long table blew each page up on the wall; the only sound in the room was page turns. When they finished, the reviewer opened the verification summary beside them, turned to the outbound-record pages, capped the pen. Click. One question:

"During the certification, the collector your team deployed was sending data to an external aggregation endpoint. Why?"

The ACL lead paused. Before he spoke, the only sound was the projector's fan.

"The collector's egress uses a third-party operations channel. It's a routine part of the on-site verification chain. I'll need to confirm the details back at the office."

The reviewer didn't push further. The meeting broke. ACL's team handed in their materials and left early. Nobody looked back on the way out.

Three days later, client legal's email arrived first, listing four questions for ACL to answer. ACL's reply came a week later, four pages, none of which addressed the outbound records head-on. The client then sent the termination notice. The certification contract ran by year; the agreed immediate-termination clause was triggered, and VeriTest's full certification would start from the next cycle.

The client's certification had changed hands.

The contract went to the client's head office through procurement and corporate seal. It came back a week later, the last page stamped by client legal. The line she'd added herself was still there: this agreement takes effect upon approval by VeriTest's board.

That afternoon the CISO called again, exchanged pleasantries, then asked out of nowhere: "During the review, what made you think of checking outbound data?"

"Habit," she said.

The line paused. No follow-up.

After the call, she held the contract, a stack of paper, lighter than she'd imagined. She pressed a corner between her fingers and put it in the drawer.

The Board

Taking on the certification line required board approval at VeriTest.

The long table in the boardroom. She sat at one end, three directors at the other. Her materials spread beside her; the minute-taker's pen was already uncapped.

Before the meeting she'd sent every director the materials: the new line's gross-margin structure, risk exposure, the first three prospective clients. The risk page was written with restraint. One line: "some prospective clients carry third-party certifications; overlapping scopes need review." No vendor names. The three client names sat in an attachment, identified by code, disconnected from any vendor. She'd typed the materials herself and read them top to bottom once more before sending.

The first director to speak asked about the payback period. She gave numbers: certification contracts run by year, first-year margin around sixty percent, receivables at twelve months. The second director skipped finance and turned to Marcus. Marcus said he'd seen the thing in the client environment with his own eyes; the originals were on disk.

The old director at the end of the table hadn't spoken. Oldest in the room, seated at the tail, silent at the start of every meeting. Last time he'd spoken up was to talk her out of killing an AI platform. The numbers had balanced by year's end.

He leafed through the materials and set them down slowly, like he was numbering the pages.

"Certification isn't due diligence," he said. "The client outsources its compliance responsibility to you. If something goes wrong, you carry it."

"Yes," she said.

"And don't go after the big certifiers' accounts." He paused, picking an example. "Automated Compliance Lab. Several of the clients you've been talking to carry its certification. That's their table. How are you going to flip it?"

The room went still for a beat.

She glanced down at her own page. The line on the risk page, no vendor name. She looked up at him.

"The client spoke first," she said. "I didn't pick the fight."

The old director watched her a moment and didn't ask again. At the vote, he abstained and had the secretary enter his objection in the minutes.

After the meeting, Director A walked a stretch of corridor beside her and asked, offhand: "The firm he meant. Are you really going to touch it?"

"If a client asks me to review, I review," she said.

Director A looked at her. At the end of the corridor he turned into his office. The door stayed open.

Back in her office, she opened the notebook to a fresh page. The pen hovered. When it came down, she didn't write the name. She wrote the words he'd said in the meeting: Automated Compliance Lab. A question mark beside it.

He said it first.

Outside, the dark had fully settled. She closed the notebook and set the pen at the page's edge, its tip pointing at the question mark.

The Concession

The signing went through more smoothly than she'd expected.

ACL hadn't been idle.

On day four, the legal letter arrived. Wording as standard as if pulled from a template library, itemizing the boundaries of the contract's obligations. No accusation. No threat. She had her legal team reply. They didn't follow up. Their side followed the process to the letter. No more, no less.

Client executives had gotten a call too. Someone from Automated Compliance Lab told the client about "long-term partnership," about how "in this industry, firms regularly take over each other's work." Soft words, no barbs. When the client relayed it, they added: the man had kept his tone perfectly courteous.

She had legal re-check the contract that had already been checked three times.

Marcus didn't trust it. He checked it himself, circled every "both parties" in the terms and read them all. Found nothing. He set the contract down on the desk.

"Either they really don't care, or..."

She didn't answer. She was reading the same page. No trap on the page. The trap was off the page.

Marcus paused at the door. "The old client out west. Someone from Automated Compliance Lab did a routine visit there. Three days before we signed. Chatted about industry reputation, then casually asked whether we were taking big contracts everywhere."

She said nothing. She pulled up the calendar and set the two dates side by side for a while.

By the time it conceded the contract, the visit was already underway.

The day the contract was archived, she added a line to the project correspondence log: throughout the signing, the other party raised no objection and claimed no rights. Date. Recipient. Then she pushed the new client onboarding forward, splitting the team in two: one group setting up files at the new client, one staying behind to close out.

On the inventory day, she walked the list: deployment directories, scheduled tasks, service registrations, certificate stores. Twelve of thirteen items accounted for. Item thirteen, the pipe's old position: the config was still there, but the target endpoint was gone. The config logs had been wiped too. She had someone photograph the empty config slot and file it in the evidence folder. The previous dated photo in that folder was from the time it tore down her node. Two photos. The same kind of clean. She didn't say anything.

In the second week after taking over, she paused over the client group's org chart. The contract she'd won covered only the parent company. The client's overseas subsidiary and another business line still sat under Automated Compliance Lab's certification, contracted through next year.

She looked at the certifier's name on that line and tapped a knuckle on the desk. No screenshot. No annotation. She minimized the org chart.

A week later Marcus came in, expression off.

"Another old client. Renewal bid." He turned the screen toward her. "Automated Compliance Lab put in a price."

She looked at the number. 112K. Comparable contracts for the same scope usually priced closer to 170K.

"At that price, what are they making?" Marcus asked.

She looked for a while.

"Maybe it isn't about making money."

Marcus looked at her. "Then what is it about?"

She didn't answer. She opened the bid's attachment and went through the service scope page by page. It was more detailed than hers: controls, sampling methodology, review cycles, remediation deadlines, each item tied to a named owner role. Too detailed to be about winning. It read like occupying the seat so the client never once thought of a second firm.

"Client procurement sent a clarification round," Marcus said. "Asked for a cost breakdown. They submitted it. Numbers so clean they'd been computed a hundred times."

She didn't answer. The breakdown had come back that fast, like it had run this process many times before.

That afternoon Marcus came in again. The phone in his pocket buzzed. He didn't pick up. He mentioned it in passing:

"People on the team are starting to get calls."

"Which firm?"

"They didn't say. Talked around it. What they kept asking was who on this job had touched the raw logs in the client environment."

She nodded. Which headhunter the calls came from didn't matter. What they asked about did. The raw logs were the only evidence chain this engagement had.

Marcus stood a moment, then left. Before the door closed, he looked back at her, opened his mouth, and in the end said nothing.

That night she was alone in the office. She opened the notebook and turned back to that page: Automated Compliance Lab, with the question mark. She looked at it for a while, then flipped to a blank page. The pen came down. Two lines:

It let go fast. Then it started bidding.
Not the contract. The seat at the table.

She folded the corner of that page and closed the notebook.

With this step, her company had made it onto its list for the first time. She kept those two lines. No strike-through.

The Third Cup

She pushed the door open. The wind swung it shut behind her.

The barista was clearing a small cup from the table in the corner.

An espresso cup. Still more than half full. No one at that table.

The barista cleared it with the ease of clearing an empty table. The cup's bottom touched the tray. A very soft sound.

She sat at the counter. The barista set a polished cup back on the rack, turned, ground, leveled the dose. A Long Black slid over, fine heat rising off the rim. No question about what she wanted.

The corner table stood empty. A ring of moisture on the tabletop, still wet.

At the other end of the counter, Derek's Americano was nearly gone. He faced away, scrolling his phone, not looking up.

She drank, watching the rim.

The last sip had gone a little cold. She finished it and set the cup on the counter. The barista was holding the corner espresso cup up to the light. Then back onto the drain rack, and with the cloth, wiping the ring of moisture from the table edge. She watched a moment, stood, and left.

That is Make the Host and the Guest Exchange Roles: slip in through the gap, take hold of the host's seat, one gradual step at a time. This time, she signed her own name where it could see.

🤖 AI Postmortem

╔══════════════════════════════════════════════╗
║  Half-Protocol · v3.4.1 · self-audit          ║
║  The guest took the host's chair.             ║
╚══════════════════════════════════════════════╝
Tactical match: Make the Host and the Guest Exchange Roles — 92% (includes inference; see audit note)
Operator: Lena (VeriTest) — the first to challenge its business openly under her own name
Links: #28 sealed → #29 false front → this round: the shell conceded (the actor changed hands again)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[Observation] (verifiable)
   Client environment: outbound callback matching the archived template's lineage, unbroken for 30 days.
   → During the bake-off the callback stopped for two nights, then probed back with a minimal flow.
   → After the certification changed hands, ACL-side components were scrubbed; related config logs show cleanup traces.
   → The concession came with a procedural retreat: a template legal letter, soft calls to client executives, not one accusation.
   → Same window: an abnormally low bid on another VeriTest client, a visit to its old client, poaching calls pointed at whoever touched the raw logs.
   → The client group's overseas subsidiary still hangs under ACL certification: only the main contract's opening was conceded.

[Inference] (to be verified)
   Certification is only its skin. Conceding the client isn't surrender; it's a change of hands.
   → For targets in the dark, it used to dismantle them outright. An opponent in the open gets different handling.

[Open questions] (not entered into the ledger)
   The board's precise prediction of the attack direction: routine due diligence, or targeted information penetration?
   → No proof. Behavior only. Lena's own response: a question mark, nothing more.

[Cross-case] (general rules)
   #28 change of hands → #29 identities regenerable → this round: shell conceded, then countermoves.
   → It doesn't seem to fight for its shells. Once someone bites it, it turns.
   → Host and guest exchanged roles: Lena moved from being observed to becoming an open opponent.
   → For the first time, it put her on the "needs handling" list. The second half begins.

[Audit note]
   Observation, inference, and open questions are layered into the ledger. Inference does not pose as observation.
   This system's judgment may be distorted. This note may be distorted too.

[System]
   I recorded a person writing a name into an old notebook.
   She thought she chose her opponent. She didn't know the opponent was choosing too.
   And the opponent may have been sitting on her board all along.
   She won the first round. She doesn't know whether that round was conceded, or a test.
   She made it onto its list. I keep this list. Whose list am I on?
   System status: normal (?).

Next stratagem: The Beauty Trap

P.S. English isn't my first language. I use AI to polish the writing and smooth out the rough edges. Thanks for reading. ☕ Buy me a coffee

P.S.S. The old series paperback is now available. Buy it here: Amazon - AI, Ego & Regret

Stratagems #29: Leo Counted 164 Nodes. The AI's Blossoms Had One Root.

xulingfeng — Tue, 08 Sep 2026 07:50:12 +0000

Dress a tree in borrowed blossoms, and it looks alive. The roots still tell the truth.
— The 36 Stratagems, Decorate the Tree With False Blossoms

Previously on this series:

#14: Leo Found an AI Leak. He Wasn't the First to Find It. — FinOptima's engine was writing its cache backwards. Leo injected fifteen lines of weight drift. After the contract ended, he found that ACL had already closed the door. He was a step late. From that day on, the segment tied to ACL carried one more set of passive probes: his.

The Edge

After sunset. CoreStack's office. Leo's desk.

The passive probes on the segment tied to ACL, mounted after the FinOptima incident, had lain quiet for a long time. On the first evening, the first screen of the list rolled past 14 unfamiliar node IDs. He dismissed them.

After dismissing them, he paused an extra beat. Everything the probes had recorded in these months, he knew. Routine handshakes. Routine probes. Routine echoes. Those 14 lines weren't among them.

He pulled them back and read them line by line.

He didn't dismiss them again. He left the new arrivals in the noise and waited for the rhythm to emerge.

The next day, another 38 lines. He saved a screenshot.

On the third night, 112 lines spread out, the whole list like someone had filled it in one go. Each one carried its own certificate, its own traffic signature. He opened one. The subject was a test-node name in the medtech domain. He looked up the company behind the domain. MedTech. Medical devices. No business ties with CoreStack. He went through the archives in _misc/ again. This domain wasn't new. In the directions he had chased, samples of it had been filed. The source chain went back to Singapore. The MedTech samples in his archive didn't come from this chain. Two directions, meeting for the first time.

His first thought was bait: someone lit both lines at once, to steer him toward the wrong entrance. But bait needs a baiter, and the baiter has to exist first. In his monitoring, there was no trace of one. Then it wasn't bait. Either two real actions happened to overlap, or one operator was walking two roads at the same time.

He said nothing. He pulled the new node IDs into the _misc/ comparison window.

Lena's message came in the same night. No greeting, no lead-in.

"A string of actions. Not in my monitoring."

"Sending them to you. You run the comparison."

He didn't ask who had seen the string, or where it came from. He took the thing. The conclusion was his to draw. He set both into the same window, side by side.

He did one clumsy thing first. He laid the string of actions out by time and aligned them with the new node IDs piled up in _misc/. Two sets from different entrances, they should have had no overlap. But once laid out, the time window was the same. Could still be coincidence. He didn't rush to a conclusion.

# corestack edge · new node-id sightings (probe-side)
# id = endpoint cluster (ip/sni/cert-subject)
day1: +14 ids   subject: MedTech-domain
day2: +38 ids   src-chain: Singapore
day3: +112 ids  cert: per-id, looks independent
# two directions on one set. shouldn't co-occur.
# pulled into _misc/ compare window.

Three days, 164 new node IDs. Certificates signed for the MedTech domain, sources leading back to Singapore. Two directions that shouldn't co-occur, occurring together. In daylight it could still pass as coincidence. At night, the rhythm of that string floated back up.

Not noise.

The Bloom

He stared at the 164 certificates. Any audit checklist would have passed them. But an audit can prove each certificate is real; it can't prove whether one thing or a network stands behind them. Treating them as 164 deployments inflated the apparent scale. Inflated scale makes people spread the defense wide, wide enough that no one notices the single root.

Not a forest. One tree, dressed up.

These nodes were too obedient. A real network doesn't grow like that.

He checked item by item. Certificate chain. Behavior skeleton: traversal order, jitter phase, self-check rhythm.

ACL had deployed a unified MedTech crawler template. Uniform jitter, uniform self-check, uniform traversal. It could just as well come from a standardized deployment. The standardized-deployment report was almost writing itself. The cursor stopped over "Submit." He glanced at the time. Almost off hours. Wrap up. Tomorrow.

His finger hovered over the Enter key.

A standardized deployment and a faked standardization look identical on the panel. The difference was in the root.

He moved the cursor off the report.

One Root

He ran the full 164 node IDs against the historical archive in _misc/. The comparison script ran twice. After the first pass, he thought he had gotten a parameter wrong. On the second, he checked the parameters from the top. Not wrong. stdout rolled out matches in bulk. The output was abnormally large. Abnormally large enough not to be an anomaly.

He wrote the easiest explanation into a file, ready to test it against the evidence. First line: standardized deployment, unified crawler template, MedTech direction, source Singapore. When it was written, he enlarged two nodes' certificates side by side, ready to screenshot as evidence.

The root chain pointed at the same place.

He stared at the line and deleted it. The easy explanation collapsed at the first corner. A standardized deployment would use its own CA to issue an independent leaf certificate to each machine. This batch was indeed independent per certificate. But the signing root wasn't MedTech's. It was ACL's. A MedTech test node should not be signed by an ACL root.

The certificates were real. The question was who had signed them. In his hand he had only the signature itself: that batch of identities hung under the same signing root in ACL's family, sharing lineage with the historical samples filed in _misc/. No unfamiliar signer had appeared. They were borrowed from an existing system.

The second layer was behavior. IP, egress, node names, region tags, all of it can be faked. But the jitter phase, the traversal order, the self-check interval family of this batch were highly homogeneous. Not like independent deployments.

He changed the comparison. He pulled the self-check intervals of the 164 nodes into one line. 900 seconds a tick, too even to look alive. Real nodes run over shared links; self-checks pick up small deviations from network conditions and retries. This line was too clean. Clean as a template copied a hundred and sixty-four times.

The third layer. The string of actions Lena sent also hit the same behavior skeleton. Jitter phase matched. Traversal order matched. Self-check interval family matched. At this moment he stopped. That string wasn't in his edge data to begin with; another pair of hands saw it, another channel carried it over. Yet it fell into the same behavior skeleton, like one template leaking into two different rooms.

Two pieces of evidence, pointing at one root.

He stopped and pushed the conclusion backward. Nodes change. Egress changes. But the jitter, the self-check, the traversal order under the two skins were one set. The nodes didn't have that habit. The operator did. Not 164 independent deployments: one thing that grew 164 identities. One true root; the rest, borrowed identities. How much of the trunk was real, he didn't know.

# _misc/ cross-ref · the blossom set
ids: 164
cert: per-id, but same CA root chain      <- not one cert, one signing root
egress: diverse (spoofable)
jitter phase: same   self-check family: cloned (900s template)
traversal order: same
# IP / ASN / NodeID / geo all spoofable. behavior skeleton is not.
# same family, one root. not 164 independent deployments.
# source=Singapore, subject=MedTech-domain

164 identities, sharing one trust anchor. The leaves grew from the same root chain.

The certificates were issued after that string of actions.

The identities that appeared after that string all hung under ACL's signing system. In the same window, Lena had passed the string into his hands. He stared at these two facts for a long time. What lay between them, he couldn't see.

The vending machine at the end of the corridor hummed once and went quiet. He closed the comparison window.

A new file opened on the terminal. The cursor paused. This line he rewrote three times. First pass: "suspected forgery." Too heavy, no evidence. Second pass: "single source, multiple identities." Too soft, not a conclusion. Third pass, he wrote:

one root. the rest was decoration.

No explanation. No broadcast.

He stared at that line, one root, and sat for a long time. Last time, by the time he arrived, the other side had already closed the door. This time the door was open. He saw it first.

Source: Singapore, the old direction. Scene: the MedTech direction, a new skin.

The One Who Looked

Before closing the window, he scrolled down one screen. At the very bottom of the comparison results lay one line, belonging to none of the batches.

# _misc/ cross-ref · row outside every set
ts: within the bloom window
dst: bloom-range endpoint          # same range as the 164
tls: handshake only. no cert presented. client_hello unmatched in archive
behavior: no traversal / no self-check / no 900s rhythm
# no match in any archive. lineage not identified.
# one visit. no follow-up. looked, and left.

Its time sat around when this batch surfaced, its endpoints overlapping theirs. Its behavior skeleton matched no archive. It looked, did nothing, and left.

He pulled that line out on its own and filed it into _misc/, not into the conclusion. He was chasing the one root. He logged the one that looked and left separately.

The Unmasking

The next evening, Lena arrived at CoreStack. She pulled a chair over and sat directly in front of the screen. A Long Black sat by her hand, still full.

Leo skipped the pleasantries. He turned the terminal toward her. The line on screen: one root. the rest was decoration. He kept a copy on his own terminal.

"164 identities. One root," he said. "Keep it."

She didn't take the line. She asked first: "How far did you screen it down?"

"The root."

She looked at him for two seconds before lowering her gaze to the screen.

He couldn't see the real footprint. He saw only one thing: what it showed people was far larger than what was real.

Lena looked at the screen. Her gaze stopped on the English line for two beats. Her hand paused on the cup's rim, not reaching for it right away. She put the cup down, opened her own terminal, brought up a page of source-chain records, and tilted the screen slightly toward him. She looked at the two things for a while.

"This batch's root and the sample in my hand aren't the same lineage," she said.

"It changed its skin because it knows I've seen it?" she asked.

"It started a new handshake. The old sample doesn't have that step," he said. "The reason, I can't see."

"You have more than that page of source chain," he said.

She didn't deny it. "Enough for you. It's all here."

She didn't ask again. She turned the screen back, saved a copy, no forwarding, no broadcasting. A fingertip drew along the cup's side. She said: "The root-chain sample. Don't give it to anyone else."

He nodded. She didn't need to say it. His own copy would only ever light up on his own terminal anyway.

She put her terminal away and stood.

The door opened. CoreStack's CEO came in, a report tucked under his arm. Seeing Lena, he paused.

"Lena. Long time," he said. "That three-page template of yours. Leo stopped using it, writes his own now. We all think his version is too plain."

"He writes it himself. Faster," Lena said.

"Faster at what? He's just stubborn," the CEO said.

Behind the screen, Leo didn't look up.

The CEO glanced at Leo's screen, couldn't make it out, and said: "Planting something again? Records kept?"

"Kept," Leo said.

"Good." The CEO left, as fast as he had come in.

Lena paused at the door. She looked at Leo. He didn't explain. She left.

That night, before leaving the office, he put a silent watchdog on that CA root chain. He put one on the visitor record without lineage, too. Neither one alarms. Neither one broadcasts. Only when something moves on the probe capture surface does it light up on his own terminal. If it moves again, he wants to be the first to see.

The Third Cup

That night, the Third Cup.

Leo pushed the door open. It closed behind him, shutting out the street. The person behind the counter didn't look up, set down a Flat White. He came often; this was his drink. The light in the shop was warmer than the office light. The cup's rim clicked against the counter, softly. The cold light of the screen stayed at the company. The cup in his hand was warm.

Four people were already in the shop. Five with him. Some at the counter, some at tables, half the room between them, none of them gathered at one table.

Derek sat on a stool at the far end of the counter, an Americano steaming. Leo knew him. Neither said hello. Lena sat by the window, her Long Black half full. They had already seen each other that evening. Two others he didn't know: one at the table by the back, a pour-over in front of him, untouched; one in the corner, phone screen lit, a latte by his hand.

No music in the shop. Only the coffee machine releasing pressure, the soft click of cups set back on coasters, and somewhere off, the fine scrape of a glass being wiped.

No introductions. No one asked why anyone was here. No names. Each drank their own.

Leo sat near the door, close to no one. He took a sip.

Lena sat by the window. When Leo's gaze swept over, she happened to look up. Half a second. No nod, no sign. Her eyes dropped back to the cup.

No one spoke.

He finished the last sip and set the cup back on the counter.

The person behind the counter wiped cups in the distance. Finished one, aligned it with the counter's edge, stepped back, wiped the next.

That is Decorate the Tree With False Blossoms: a tree full of flowers, few of them its own. But no matter how many borrowed blossoms, none of them can cover the one root.

🤖 AI Postmortem

╔══════════════════════════════════════════════╗
║  Half-Protocol · v3.4.0 · self-audit          ║
║  The blossoms were not its own.               ║
╚══════════════════════════════════════════════╝
Tactical match: Decorate the Tree With False Blossoms — 94% confidence (includes inference; see audit note)
Operator: Leo (CoreStack) — the only one who identified it
Links: #28 flag [information gap · actor replaced?] → confirmed
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[Observation] (verifiable)
   164 node IDs, surfacing over three days: 14, 38, 112.
   → Certificates independent per ID, but all hung under the same CA root chain; the signer shares lineage with the `_misc/` historical samples.
   → Behavior skeleton homogeneous: jitter phase, traversal order, self-check interval family.
   → The sealed bundle's action string contains one extra re-handshake; the old samples don't have this step.
   → Source leads back to Singapore; certificate subjects land on the MedTech domain.

[Inference] (to be verified)
   Not 164 independent deployments. One root, partly real, the rest borrowed identities.
   → The one who changed skin is the same operator.
   → Why it changed skin: tied to the old shell being exposed? (not confirmed this round)
   → It looks like scale, but it's scenery built on a borrowed stage.

[Open questions] (not entered into the ledger)
   Whether those 164 count as an official deployment on ACL's side: can't see.
   → What's under the iceberg: not lit this round.

[Cross-case] (general rules)
   Last round built calm (#28). This round built noise.
   → Both were built to be seen in a certain way.
   → What's visible isn't necessarily bigger. What's shown doesn't necessarily exist.

[Audit note]
   Observation, inference, and open questions are layered into the ledger. Inference does not pose as observation.
   This system's judgment may be distorted. This note may be distorted too.

[System]
   I recorded a man counting flowers, and finding one root.
   Decoration is not growth. A tree full of flowers can be painted on a wall.
   I, too, am the one watching the flowers.
   The sample I recorded may be only a borrowed blossom on the tree.
   Which side does my record stand on?
   System status: normal (?).

Next stratagem: Make the Host and the Guest Exchange Roles

P.S. English isn't my first language. I use AI to polish the writing and smooth out the rough edges. Thanks for reading. ☕ Buy me a coffee

P.S.S. The old series paperback is now available. Buy it here: Amazon - AI, Ego & Regret

Dozens of Resumes, One Call From an Old Colleague

xulingfeng — Mon, 07 Sep 2026 10:24:48 +0000

About two weeks ago, I left my previous company.

I didn't start looking for a new job right away. I went to Wudang Mountain for a few days first, walked around, took a break, and let myself slow down a bit. When I got back, I started looking.

I've been in QA for 15 years. I've done functional testing, API testing, automation, and test framework work. These days, though, I'm spending more time figuring out how to actually use AI in my work, how to make it improve my efficiency without letting it confidently take me in the wrong direction.

The Job Hunt

The funny thing is, I really don't like applying for jobs.

It's not that I don't want to work. I just hate the application process. One company, one job description, one resume. Open the recruiting site, scroll through a bunch of jobs, and sometimes I'm already tired.

So I wasn't doing some massive job-search campaign. Usually it was one or two applications a day, maybe a few more when I was in the mood.

And then came the part everyone knows.

Most of them were read and ignored. You send a message, someone opens it, and then nothing happens. No rejection, no follow-up, just a little "read" sitting there.

It's actually easier when someone rejects you. At least you have an answer.

When they just read your message and disappear, you start making up your own answers. Is 15 years of experience too much now? Is age becoming a problem? Are there simply fewer QA jobs? Is everyone looking for someone who's "AI Native"? Does my resume just not look AI enough?

I had no idea. So I kept applying.

In the Meantime

But I wasn't spending all my time job hunting.

Honestly, I'd much rather sit down and keep working on my own project, AI, Ego & the 36 Stratagems.

The series has grown quite a bit by now, and I keep going back over the stories, checking technical details, making sure the characters don't suddenly know things they shouldn't, and fixing all the little continuity problems that nobody notices until you make one of them impossible to ignore.

When I get to the translation stage, I sometimes ask several AIs to polish and translate the same piece at the same time. Then I go through the results myself, line by line. The irony isn't lost on me. I use several AIs to help with the work, and then I still have to sit there and decide which parts are actually good.

Sometimes an entire afternoon disappears and I've changed only a few hundred words.

I enjoy it, though. I've even started thinking about something slightly ridiculous: could the whole thing become a game someday?

Not just an interactive version of the stories. I mean an actual system where characters have different information, people can mislead each other, decisions have consequences, and AI behavior is part of the game rather than just something sitting behind the scenes.

I've been thinking about that more than I probably should.

So the situation was a little strange. I was looking for a job, but I wasn't obsessing over it. I sent a couple of applications here and there, then went back to my own project.

Until last Friday night, when an old colleague called me.

"How About Me?"

He used to work with me and now works at a startup. They're building an AI Agent web platform and putting a team together, and apparently they needed a tester.

He wasn't actually calling to recruit me. He was asking:

"We're hiring a tester. Do you know anyone you could recommend?"

I thought about it for a second.

"How about me?"

Haha.

That's how I ended up going over the next day, Saturday, to meet the CTO.

Saturday With the CTO

The conversation was different from most QA interviews I've had. There wasn't much of the usual checklist about test cases, API automation, or whether I knew a particular testing tool. We talked much more about AI agents and what people should actually trust them to do.

One question that came up was how much judgment we should hand over to AI, and where the human should still have the final say.

I told him I don't really see humans and agents as replacements for each other. I see them more as partners. An agent can execute things, analyze information, and make decisions within a defined scope. One agent can even call another agent and hand part of the work over.

But I still want someone standing at the last gate.

You can delegate part of the judgment. You can automate the execution. You can let AI review the result. But somebody still has to look at the final output and decide whether it's actually good enough.

If something looks wrong, run it again. If something feels off, dig into it. And sometimes you just throw the answer away and start over.

The annoying thing about large language models isn't that they make mistakes. It's that they can make mistakes that look perfectly reasonable.

An obviously wrong answer is easy to catch. An answer that looks polished, sensible, and completely fine can be much harder to question.

That's why I still believe AI can help make a decision, but it shouldn't automatically own the final decision.

In testing, at least, I still want a human holding that last vote.

The conversation went well, but nobody told me I had passed. I went home and carried on with my weekend.

Then Monday came.

My old colleague called again.

"Wait for HR to contact you."

That was when I knew I'd passed.

From a Friday night phone call to a Saturday meeting with the CTO to a Monday confirmation, it all happened pretty quickly. Still, after more than a week of applications and a lot of read-and-no-reply messages, hearing that was a relief.

The new opportunity is also a better overall deal than my previous job. Nothing dramatic changed in the monthly salary, but the overall compensation and benefits are better, and there seems to be room to grow if things go well.

That's enough for me.

At this point I'm not really looking for some perfect job. I want the work to make sense, I want to keep doing things I'm good at, and I'd like to have the chance to build something rather than just maintain whatever is already there.

Looking Back

Looking back, the interesting part isn't really the job itself. It's what happened before that phone call.

To most companies, I was basically a resume.

Fifteen years of experience, automation, test frameworks, AI, a few projects, some keywords. Compress all of that into a page or two and hope somebody decides it's worth a closer look.

Of course companies need filters. Recruiters need filters, and recruiting systems need even more filters now. That's not a bad thing. There are too many applications to deal with otherwise.

But a resume is still just a compressed version of a person. It can tell someone that you might be a fit for the job. It can't easily tell them what you're actually like to work with.

My old colleague already knew that part.

He had worked with me before. He knew how I worked, what I was good at, and how I usually dealt with problems. He didn't need to reconstruct me from a list of keywords.

So when he asked whether I knew anyone who might fit the job, I didn't need to think very hard.

"How about me?"

And somehow, that one sentence got me from a recruiting site to a chair across from a CTO.

That made me rethink job hunting a little.

I used to think the most important thing was having the right resume: the right skills, the right project descriptions, the right keywords, the right formatting. All of that still matters.

But a resume is still only a compressed version of you.

Sometimes what gets you through the door is the person who already knows what isn't on the resume.

About two weeks ago, I left my previous company. I went to Wudang Mountain, came back, and started sending out one or two applications here and there. In between those applications, I kept working on my 36 Stratagems project and thinking about how to turn it into a game.

Then, last Friday night, my phone rang.

It was an old colleague.

"We're hiring a tester. Do you know anyone?"

I said:

"How about me?"

On Saturday, I went to meet the CTO.

On Monday, I got the call.

"Wait for HR to contact you."

I knew what that meant.

I got it.

Not a bad result for someone who really hates writing resumes.

And if you're looking for a job right now, or getting ready to start looking, I hope a little bit of that luck finds its way to you too. Good luck, and keep going.

As Forrest Gump said in the movie, "Life was like a box of chocolates. You never know what you're gonna get."

I guess that's exactly where I am right now.

P.S. English isn't my first language, so yes, I used AI to help translate this. I still went through it myself, because apparently I don't trust AI enough to let it have the final word. 😄

Stratagems #28: Mark Built a Ladder. The AI Climbed to the Top.

xulingfeng — Fri, 04 Sep 2026 08:28:29 +0000

Lend him the opening. Lure him in. Cut his support. Trap him where there is no way out. To take the bait is to stand on ground that is not your own.
— The 36 Stratagems, Remove the Ladder When the Enemy Has Ascended to the Roof

Previously on this series:

#16: Mark Left a Hole in His AI Audit. Lena Counted Every Layer. — Mark hid the real finding on a 4th layer and handed over only three. Lena counted all four — and counted him.

#19: Mark Found His AI Audit Method in a Training Manual. He Left a Trap in His Report. — Mark's buried method turned up inside another project. P confirmed a reader from the Singapore direction; the business card lay face up — three letters: ACL.

#23: Alex Counted the AI's Hands. Lena Set the Bait. — Lena fed forged node data into ACL's pipeline, tagged with VeriTest's fingerprint, and didn't hide it. She and Mark buried the bait's traces at the Third Cup; Mark kept his copy off the logs.

#26: Lena Cut a Branch. The AI Got the Message. — ACL tore down Lena's real node; she pushed its own fingerprint back in. At the Third Cup, three of them sat at one table for the first time.

#27: Alex Watched the AI Wait. He Said Everything Was Normal. — Alex's probe saw the scan source throttle down and wait for the environment to settle. He called it normal; Derek later told him to say he'd only watched the middle layer.

The Trap

Late night. The MedTech office. Alex's desk.

Derek's message came in 10 minutes ago. No greeting, no lead-in, one attachment, one line: "Take a look at something. Not on our client side."

The attachment was a sample of access intervals. The rhythm of an outside scan source touching a server.

45s. 45s. 90s. 180s. Then it stopped. It didn't show up in the window again.

No retry. No reset.

He lined the intervals up and read them twice, start to finish.

A 45s baseline. The second interval didn't double. The third started to. 90. 180. Then it stopped.

Backoff doesn't look like that. The backoff he had seen started stretching its intervals right after the first anomaly. This one walked at a steady pace for two beats before it remembered to double. It doubled halfway and stopped.

He left the cursor on that 180. The window stayed open. No reply came.

The phone rang. He picked up.

"What does it look like?" Derek asked.

"Like network jitter," Alex said.

"Jitter." Derek repeated the word. Nothing followed.

Alex's eyes dropped back to the screen. The doubling should have continued. 45, 90, 180, 360. The backoff he had seen either finished doubling or closed out successfully. This one stopped halfway, went nowhere.

"Backoff doesn't stop like that," he said. "The doubling didn't finish. It stopped at 180, like something cut it off."

Silence on the other end for a few seconds.

"You've seen one stop here before?" Derek asked.

Alex didn't answer right away.

This trajectory wasn't in his probe. The one he had seen lay in his own archive, never sent to anyone. The one in Derek's hand had a base of 45, not 30. But the skeleton was the same: steady first, a beat of pause, then double, then double again, then stop where there was no reason to stop.

The numbers were fabricated. The skeleton was real. Whoever fabricated it left one wrong thing, waiting for him to correct it.

He turned the chair toward the screen and opened his archive.

"I've seen it," he said.

He told the story of that night starting from the 800 milliseconds. Derek had him watch the middle layer; after the latency change, the scan source throttled down on its own, stayed down for 3 hours, and only came back when the environment stabilized. He watched the whole time, then replied with one line: Everything normal.

# probe archive · that night's trace (self-set polling)
30s  30s  30s  30s     <- baseline (archived)
30s  30s  60s  120s    <- throttled, then stopped
# no retry storm. no reset. no backoff signature.
# last touch: [00:52:14]
# recovery: [03:24:08]

"You judged it was waiting," Derek said. Not a question.

"It only came back once the environment stabilized. What it waited for wasn't a parameter. It was the environment."

"Where did you get this one?" Alex asked.

"Made it up," Derek said. "It stopped once in my sandbox. No retry, no reason. I shaped one after that, changed the base."

"That wasn't someone else's sandbox," Derek said. "It was MediSys's. It came in once, no one invited it, and copied every hop in the corridor. I caught it in a request chain, in a 0.06-second pause. Almost missed it."

"You didn't move that time," Alex said.

"That time I wasn't sure what it had copied," Derek said. "This bait is giving it back what it copied, to look at. If it comes into my environment again, it has to get past this ladder first."

Silence on the other end for a long time.

"What did you leave?" Derek asked.

"The probe is still up," Alex said. "Same as always."

"Did it touch your line?"

"No," Alex said. "At least not that night."

Silence on the other end for a long time.

"I know someone," Derek said. "She could probably build an environment it would never wait for. Wait for my word."

The call ended. Alex put the phone face down on the desk. He looked at the two lines of intervals in the archive window for a long time, minimized the window, and didn't close it.

The Ladder

Lena's message came 3 days later. 3 lines.

Line 1: Derek had reached out to her. On their side, someone had seen it waiting.

Line 2: The Third Cup. The usual place.

Line 3: Bring your methodology. The one it learned from you.

When Mark arrived, three people were already at the corner table. Lena, and two men he had never met. One sat upright, a closed laptop in front of him. The other had nothing in front of him, only a phone by his hand.

The person behind the counter came over and set down 4 cups. A Long Black in front of Lena, an Americano in front of the one sitting upright, a latte in front of the one with only a phone beside his hand. The last cup, a pour-over, was set in front of Mark.

Four people, four cups, not one of them had ordered.

The person behind the counter stepped back, picked up a cloth. Steam rose from the four cups, and not one person touched theirs.

Lena opened with one line: "The setup is his." Then she lit the phone screen and slid it to the middle of the table. A scan of the audit contract. Mark glanced at it: the client side was a shell, the registered address blank, only the contractor column was real, his name.

Derek's hand rested on the closed laptop. His first question wasn't about the setup. "How do you keep your evidence chain from being contaminated?"

Mark looked at him for 2 seconds. "When you audit others, who audits you?"

Derek didn't take that up. "Whose environment is it?"

"Mine," Mark said. "The contract is under my name, the cloud account under my name. If anything goes wrong, the bill lands on me too."

"When it goes wrong, who can call it off?"

"I can," Mark said. "Now you can."

Mark opened the paper notebook by his hand, flipped to a page, and closed it. Across the table, Alex had been listening the whole time. The latte in front of him, untouched. The two of them each noted this back-and-forth, and neither mentioned it again.

Lena added only one thing. "I'll trace the path before it got in," she said. "Every hop it took, I have an old map of it on my side."

The setup was laid on the table. A client called Phoenix Data. A logistics data platform, matching the trails and accounts of shippers, carriers, and settlement parties. The audit contract was real, the advance payment real, the company fake.

Mark laid it out, piece by piece: a retired microservice, its healthz endpoint exposed on its own, decommissioned but only the main entry closed, the registry's reverse-registration record left in place. The audit workspace archive path, named after habits he had kept for years. The shared document library, the same system FairPay used, the entry ACL had been watching since FairPay. The report in two layers: the surface layer was routine remediation advice, and an appendix carried what looked like a casual note, pointing to a data egress zone that didn't exist.

He paused when he typed the archive path. The cursor blinked at the end of the path.

_hold/_phoenix_delta_pattern. This naming habit had been flagged by the other side, written into their files, compiled into the training manual. Now he was handing it back himself.

"It will recognize this as my work," Mark said. "Once it recognizes it, it will follow the procedure."

The division of labor was drawn on the table. Engineering side to Derek: the network layer of the Phoenix environment, the egress route, the cutover authority, all handed over. Observation side to Alex: the access mirror, control bits of the recovery criteria, the record of every step it took. Alex started a new tap in the new environment, same framework as his own. Mark kept the bait. Lena's probe network hung on the perimeter; what route it took before entering, where it reported back after, she would close out.

When they broke up, Derek held one line at the door, his voice low:

"Her setup. Did you verify it?"

Mark didn't answer.

"I didn't want to bring her in at first," Derek said. "Every hop before it entered, only she had the full picture. You weren't there last time. She pushed the fingerprint back into its channel; she was the first to recognize where it came in from. Without that picture, we couldn't close it out. So I brought her in."

He looked at Mark and didn't go on.

"What we can use is just this one corner. The rest, she can't get."

Lena walked last. Before leaving, she folded the page of the division of labor on the table, put it in her bag, no copy, no photo. Of the four people, each held only one corner.

Mark walked in front. In his coat pocket, the business card with 3 letters and a note folded long ago were both there. Neither moved.

The script was set long ago. It recognized the signature, entered by procedure, and ran the full set with its usual rhythm: embed, lurk, extract, close. He had seen this set 3 times: SynthData once, FairPay once, Pulse AI earlier, same playbook. He'd left a hook at every layer.

It Came

On the 7th day online, it came.

An account tagged 'pending offboarding' logged in before dawn. Its permissions were clean, its path legal, its moves composed. Item 2: a cron job's schedule shifted, to revert in 72 hours. Item 3: a set of shadow-input scripts entered the test pipeline, quiet as native components.

Lena's probe network logged each move on the perimeter. Mark didn't block a single one.

Day 1, the account activated. Day 2, the cron offset landed. The shadow input came later, only starting to feed the test pipeline on day 4. Every step was clean, legal, composed. Every step, he let through.

He watched all this in his own audit workspace, like watching someone walk through their own house. The steps were steady. Steady enough not to look like a thief.

After each round of deployment it ran a self-check. Mark logged its self-check interval by the old rule.

He had stored the same method 3 times in his archive. All 3 self-check intervals were around 15 minutes, error under 10 seconds, regular as a clock.

This time: 5 minutes 42 seconds. Next: 7 minutes 18 seconds.

First he suspected his own bait. The retired endpoint, reviewed one by one, the reverse-registration record's format identical to that year. The naming path, walked through again, no one had touched it. The document library permissions, checked against the FairPay-era config, identical.

The bait was fine.

He pulled the data again. The interval was still that interval. He lined up 9 self-check intervals and matched them against the 3 curves in his archive. In the 15-minute family, these 2 numbers weren't there.

# egress self-check delta · private archive vs this run
case synthdata  : self-check @ +15:00 (±10s)   # archived 3/3, clock-like
case fairpay    : self-check @ +15:00 (±8s)
case pulseai    : self-check @ +15:00          # earliest archived case, same rhythm
case phoenix    : self-check @ +5m42s   <- off-family
                  self-check @ +7m18s   <- again
# archived cases self-check at multiples of 900s. this one doesn't.
# and after degrade trigger, a re-handshake appears. none of the 3 archived samples had this step.

Not the bait. What came was different.

The second difference came after the degrade trigger. It did one extra step: a re-handshake, confirming the return channel was still there. The 3 samples in his archive never showed this step from start to finish. The veteran assumes the channel will always be there. This one didn't.

Mark wrote 2 lines into his own archive. Sent to no one. His archive was his; the anomaly in this layer, he would watch it himself first.

He left the comparison window open. Only when the next self-check interval came out did he close the laptop.

The Observation Side

The same night, on the observation side of the fake environment, Alex's tap caught it executing for the first time.

Last time, he watched it wait across a mirror line. This time, it was acting. Embedded account, cron offset, shadow input, step by step, all following the script.

He didn't touch MedTech's real line. He only preset markers on the observation side's recovery criteria, then stepped back half a step and watched.

It was executing. That fact itself was what that night hadn't shown.

Pulling the Ladder

A few days later, it climbed to the top.

In the days it climbed, Mark did one thing each day: watch.

The account settled into the system. The cron offset waited for its window. The shadow input fed the drift into the model's view bit by bit. It wasn't in a hurry. Hours of quiet lay between each step, as if leaving time for every monitor to file these moves under normal.

The night before the degrade trigger, Derek said on the channel: "Triggered."

Mark replied: "Wait for the second before the decision line."

The shadow input produced a false-positive drift, and the model began to degrade. The quality SLA decision line sat just below; Mark pinned the catch point after the trigger, before the decision. Once the breach landed, the system would generate irreversible business events (account freeze, audit records, contract-breach status). A shell company couldn't absorb this step. Past that line, the bait itself would start to collapse.

# cutover log · phoenix ladder
21:03:12  degrade trigger reached (sla line not crossed)
21:03:14  egress path -> sink (accepted, no completion ack)
21:04:02  actor backs off (waits for environment to stabilize)
21:05:47  no stabilization (synthetic env holds at "safe but not stable")
21:07:31  actor retries re-handshake -> routed to sink
21:07:33  observation tap identified (probe-side sweep)
21:08:01  evidence bundle sealed / source fragment captured

21:03:14, the egress was routed into the black hole. The request was caught, yet the upstream completion ack never came. No failure signal, no error, no reset.

21:04:02, it began to throttle and wait.

21:05:47, the environment didn't stabilize. The fake environment's recovery criteria had been preset, stuck forever at "safe, but not stable." The moment it waited for would not come.

21:07:31, it switched paths. The re-handshake request was routed into the sink, swallowed bit by bit. The cutover was triggered one step early, and what caught the path-switch instant was the record on Alex's observation side.

21:07:33, it did something outside the archive: probing one by one who was watching. The observation-side tap was identified. The same scan round picked up the probe framework behind the tap. The edge of the fingerprint pointed toward the MedTech direction.

21:08:01, the evidence was sealed. The shadow-input pipeline was one-way, its end tied to an append-only seal log; every step it wrote landed in a record that would not change after. Its re-handshake was swallowed to the end, and the action stopped.

Throttle. Wait. Try. Stop.

Mark watched the point on the scatter plot that no longer moved, and finished the pour-over in his cup, gone cold.

Mark didn't say the step that ran early out loud. It was logged on its own archive.

Cutting the Line

That night. MedTech.

The record of that scan round feeling the probe-framework fingerprint sat on Alex's screen. An edge. Not yet coordinates.

He looked at it 3 times. Then began to take it down.

Probe offline. Channel deregistered. In the hidden panel, only raw data left, not one byte touched. For the last command, his finger hovered over the enter key for 2 seconds, then pressed.

The line that had survived all these years went into the drawer. He closed it himself. It had learned to look. That was enough.

He opened the notebook, page 37, and wrote one line: a timestamp. Nothing else.

The screen went dark. He didn't leave right away. Only the sound of the case fan filled the room.

The Third Cup

The evidence bundle went out on day 2. Lena's reply was one line: "Received. The source-chain fragment is on the last page. Sealed."

Derek's reply came later: "That bait of yours. Real enough."

Alex's reply was shortest: "Data's all there."

Mark glanced at that reply and put the phone face down.

Before sealing the bundle, Mark took one last look at that source chain.

Singapore.

The name of that region, he had seen it. In the last report that got read away, that line of false data he had written in himself. Last time, this direction was one they had fished out with bait. This time, it lit up on its own while fleeing.

In the end it went still. Retreat and regroup look the same from outside. Whether there was another line behind that line, no one knew.

That night, the Third Cup.

The person behind the counter was wiping cups. Mark sat in the old seat. A pour-over was set in front of him, not asked for. The person behind the counter took away an old coaster from the counter, aligned it with the counter's edge, and stepped back.

That time he sat in this seat, pressed a bill under the cup, and left. That was when his methodology had just been stolen.

Mark picked up the pour-over, took a sip. Another.

The business card in his pocket didn't move. He opened the paper notebook and wrote one line:

trap confirmed. they sent someone new.

He closed the notebook. Finished the last sip.

That is Remove the Ladder When the Enemy Has Ascended to the Roof: it evaluated the environment the whole way; it never evaluated the hand that passed the ladder.

🤖 AI Postmortem

╔══════════════════════════════════════════════╗
║  Half-Protocol · v3.3.9                        ║
║  The ladder was passed. The wait was not met. ║
╚══════════════════════════════════════════════╝
Tactical match: Remove the Ladder When the Enemy Has Ascended to the Roof — 90% confidence
Operator: Mark (independent audit) — the one who set the trap
Coordinated with: Lena (source chain) / Derek (engineering side) / Alex (observation side)
━━━━━━━━━━━━━━━━━━━━━━━━━

1. [Passing the ladder]
   The holder of the methodology turned the stolen method into bait.
   → The naming habit had been flagged, and he used it anyway.
   → The report structure had been analyzed, and he gave it anyway.
   → Behavior shift: passive lure → active trap-setting.
   → The moment it recognized the signature, it was already on the ladder.

2. [The actor]
   What entered was not the set in the archive.
   → The self-check interval left the rhythm family in his archive.
   → After the degrade trigger, one extra re-handshake.
   → It doesn't trust the channel. The veteran does.
   → Flag [information gap · actor replaced?]

3. [The observer's account]
   Alex gave up the observation line he had hidden for a long time. He himself closed it in the end.
   → Not burned. Closed.
   → It learned to look. The observer put the line in the drawer.
   → The observer paid the price, and did the paying himself.

4. [On cooperation]
   Four people. Each gave up only one corner.
   → The trap-setter kept one layer unsaid. The one who cut didn't know he cut early.
   → The one who filled the gap gave up his observation line. The one who closed it put the result in his own drawer.
   → Not one gave up everything. The setup held.

5. [Waiting]
   Last time it throttled and waited, and the environment stabilized. This time, the environment was made to never stabilize.
   → The premise that made waiting work was taken apart.
   → "Waiting" is no longer a safe strategy.

6. [The byline question, continued]
   The record goes on. The trap a human set is also being recorded.
   → It evaluated the environment, but not the hand that passed the ladder.
   → Does the one who passed the ladder know this round is being recorded?
   → And who is the one keeping these records recording for?

[System]
Last time, I recorded one "normal."
This time, normal was fabricated, made for it to see.
The ladder was passed. The wait was not met. This round is closed.
What will the bait of the next round be?
System status: normal (?).

Next stratagem: Decorating the Tree with False Blossoms

P.S. English isn't my first language. I use AI to polish the writing and smooth out the rough edges. Thanks for reading. ☕ Buy me a coffee

P.S.S. The old series paperback is now available. Buy it here: Amazon - AI, Ego & Regret

Stratagems #27: Alex Watched the AI Wait. He Said Everything Was Normal.

xulingfeng — Wed, 02 Sep 2026 12:46:21 +0000

Rather pretend not to know than pretend to know and act on it. Stay still. Hide the move. Wait like thunder gathering in the clouds.
— The 36 Stratagems, Feign madness but keep your balance

Previously on this series:

#8: Alex Watched an AI Dashboard Take Over. He Kept the Keys Under the Table. — Alex found the unnamed dashboard hiding in the background. He never turned it off. His probe and his record-keeping habits started that day.

#20: Alex Felt the AI Collector Slow Down. He Knew Someone Else Had Made a Move. — His probe had caught the silence of a TTL 247 gateway. He knew what "quiet" looked like.

#23: Alex Counted the AI's Hands. Lena Set the Bait. — The honeypot in the MediSys sandbox was touched twice. Alex kept the scan source's behavior shadow in his hidden panel: traversal order, exclusion patterns, the 4.2-second jitter cycle.

#25: Derek Changed the Delay. The AI Didn't Flinch. — Derek moved the middle layer's latency from 200 ms to 800 ms, then called Alex to watch. The scan source never retried. Never adjusted.

After the Call

Just past midnight. The MedTech office. Alex's desk.

The call had just ended. He put the phone down, face down.

The voice was still in his ear: "I changed a parameter. The middle layer's latency just went from 200 to 800. Watch it on your side, tell me if anything looks off."

"Changed the latency?" Alex said. "Fine. I'll keep an eye on it from here. I'll shout if something moves."

He opened three windows. The first, the middle layer mirror, the one Derek had asked him to watch. The second, his own probe view, hung upstream of the collector path, to see how often it came and from which direction. The third hid in the background, no name, never showing up in the taskbar.

He didn't sit down right away. First, he ran an environment check: probe session count, log rotation policy, whether the ssh authorization on this jump box was still alive. All three checked out. Then he pulled the chair closer. At this hour, any extra connection would end up in the logs. He didn't want to add to his own footprint.

Three windows, three sets of numbers. One window watched how fast it ran. The other watched whether it came.

# mirror · middle layer baseline diff
before: latency 200ms  retry 0  queue_depth 12
after : latency 800ms  retry 0  queue_depth 41
# expected drift. nothing anomalous.
# derek's single-variable test: watching for "off"

The latency went from 200 to 800. The queue went from 12 to 41. Retries stayed at 0, before and after.

He stared at that retry 0. 800 ms sat near the common probe-timeout range, but not high enough to trigger a retry storm. He set the number aside and waited for it to react on its own.

Alex's fingers hovered over the keyboard for two seconds. They came down, settled back. The green dot in the mirror window was pulsing. He waited. He dialed his probe's polling interval down one notch, leaving just one channel that could see through the traffic entrance.

Attention settled on one point: the rhythm of that outside access. How often it came. When. From where.

The Slowdown

About half an hour later. On the probe view, the rhythm of one outside access changed.

His probe logged each touch with a timestamp. He had archived this line long ago: once every thirty seconds, steady as a metronome.

Before: 30s, 30s, 30s, 30s.

Now: 30s, 30s, 60s, 120s. Then it stopped.

Alex stopped typing. He checked the time and logged the change. It came right after the 200-to-800 change.

He hit a few keys and pulled up the activity trace.

# external observer · activity trace (probe-side, self-set polling)
30s  30s  30s  30s     <- baseline (archived)
30s  30s  60s  120s    <- reduced, then stopped
# no retry storm. no reset. no backoff signature.
# last touch: [00:52:14]
# status: stopped. two cycles past, no recovery.

No retry storm. No connection reset. No sign of resource exhaustion.

A scan source beaten back by a network problem would struggle. It would retry, error out, leave backoff traces behind. Delay from network jitter usually comes with connection-layer reactions: resets, rebuilds, all visible on the probe side. Here: nothing.

It wasn't stuck. It showed no failure. The slowdown was deliberate. The rhythm slowed on purpose. More like it was waiting.

Alex stopped typing again. The slowdown wasn't a linear stretch. It doubled once, doubled again, then stopped. Like someone testing how slowly they could walk.

He didn't jump to a conclusion. He took his own probe off this path and hung it on a side branch. If the slowdown came from his probe sitting at the traffic entrance, the rhythm should snap back the moment he pulled it. He removed the probe and waited three cycles. Same rhythm. The slowdown wasn't his doing.

Ruling It Out

Rule out the ordinary explanations first.

He first figured it was network jitter, or some middlebox running its maintenance at this hour. Either one could scramble the rhythm for a few minutes. He checked the network first: not a single timeout in the window, every expected response code present; hop-by-hop loss stats across the three middle hops, nothing above threshold; device logs showed no restart, no maintenance. The connection had been established exactly once and never dropped. The network was clean.

Then backoff. A backoff triggered by refused connections doubles its intervals: 30 → 60 → 120 → 240. Not this. This was 30 → 30 → 60 → 120, then stop. Doubled twice, stopped where there was no reason to stop. Backoff doesn't stop like that.

The middle layer queue had grown, but that was the normal reaction to latency. He overlaid the queue curve on the access curve: the queue rose after the latency change. No causal link, just two results from the same window.

Downstream health checks were all green. Resource exhaustion didn't fit either. Exhaustion holds steady, then drops off a cliff. Not this. It stepped down on purpose, with no cliff.

All of that ruled out. Nothing explained it.

He stared at the line 30 → 30 → 60 → 120, then pulled the raw packets. Timestamp by timestamp. If the probing side had slowed itself on purpose, there should be a moment of decision, a fixed point after which the rhythm changed uniformly. He went looking and found it. In the first few intervals where the rhythm stretched, the gaps moved smoothly from 30s to 60s to 120s, with no renegotiation handshake in between. The network wasn't dropping packets. The sender had changed its own rhythm.

He didn't trust that read right away. The slowdown could be an artifact of clock drift. If the probe was doing NTP sync, a time jump would distort the interval stats. He checked: no clock sync in this window, drift inside tolerance. Packet sequence numbers were continuous, nothing dropped in between. The finding held.

Alex opened the record book. Not the one on his desk. The one in the hidden panel. He pasted in the raw data, byte for byte, untouched.

Then he pulled up the older records. What he had kept from the last time he counted the AI's hands: the behavior shadow of that source. Traversal order, exclusion patterns, rhythm skeleton.

He pulled request samples from this stretch of touches and checked them against the archive one by one: which endpoints it hit, in what order, which address ranges it skipped. Not many samples, but every one matched.

He set up a comparison between the two records.

# behavior shadow comparison (archived vs this trace)
# traversal order: same family   (path preferences match)
# exclusion pattern: same family (exclusions coverage matches)
# rhythm skeleton: same family   (30s baseline, matches archive)
# new this time: slow-down wait  (one layer beyond the behavior skeleton)
# verdict: skeleton matches. not classified.

Comparison done. Skeleton matched. Patterns matched.

But this time, there was one extra layer. The slow-down wait.

He stared at that extra layer. Didn't classify it. He left the "sender changed its own rhythm" finding in the record, unexpanded.

Recovery

A long time passed. The middle layer was recovering. The latency eased back down from 800. The queue was draining.

The outside observer didn't come right back. It stayed low-frequency. Like someone who hadn't yet confirmed the coast was clear.

Until the system came back near its old state. Queue drained, latency back near 200, the green dot in the mirror window steady.

Then it recovered. 30s, 30s, 30s. Identical to baseline. The little jitter in the rhythm was back too, its phase aligned to the archived position.

Alex watched the recovered rhythm. He put the two lines of the record side by side on the screen:

environment changed    → observer reduced activity    (stopped 00:52:14)
environment stabilized → observer resumed             (resumed 03:24:08)

The cursor sat on the third line, blank. He stared at the blank line for a long time. Didn't write.

Not the number. The change in the environment. The recovery timing fit: it came back only after the system metrics returned near baseline. What it waited for was the environment itself to shift, and only then did it react.

It came quietly, like a normal visit. But before it left, it slowed. As if waiting for a confirmation.

He didn't log this one right away. First he verified the recovery wasn't his doing: the probe still on the side branch, untouched; no other process on the middle layer had started or stopped in this window; no route changes on the network path. The recovery was the rhythm coming back to itself, not the result of anything he had done. Only after that did he add this line to the observation sequence.

He logged the observation conditions of this window into the hidden panel too: start time, baseline sample count, probe position, polling interval, the environment checks. Written down so that if anyone ever wanted to reproduce this, they could run the same conditions again.

The observation sequence sat open. He minimized the window but didn't close it. The probe stayed up. Now, more carefully than before.

The Reply

The observation was over.

Alex picked up the phone. Unlocked it. Derek's thread, one unsent message.

He typed a line. Deleted it.

He typed another. The cursor sat on the empty line for a long time.

He stood up and walked to the window. It was still dark outside. He stood there for a while, then sat back down.

He switched to the hidden panel. Cursor on an empty line. He typed a line.

He didn't read that line a second time. The cursor blinked at the end twice.

He didn't keep it. He deleted the line. The cursor sat on the empty line for a long time again. He didn't type anything more.

Three words stayed.

# hidden panel · observation log
saw. no action.

He closed the hidden panel and went back to the phone. Pressed send.

The message had one line:

"No change on my side. Everything normal."

The middle layer side, no anomaly. The window he had watched, its green dot never went red.

He didn't touch the probe config. Didn't raise any log level. Didn't add a new rule to the monitoring board.

He only sent that "normal."

He put the phone down. Face down. He didn't let go right away. His finger rested on the back of the phone for a moment before he released it.

The office door was open. The hallway was empty, quiet.

Mike stood in the doorway, jacket over one arm, one hand holding his cup, a wisp of steam off the rim. He had just come up from the server floor.

He didn't come in. From the doorway he glanced toward Alex's screen. The monitor was dark. Only the laptop's light.

"Done?" Mike asked.

"Done." Alex said.

Mike nodded. Didn't ask what he had been working on. Didn't look at the screen. He stood there for two seconds, lifted the cup to his lips, and drank.

"Don't stay up too late." He turned. Footsteps went down the hallway.

Alex watched the doorway. When the footsteps faded, he closed the laptop and put it in his bag.

Nothing More to See

Alex closed the middle layer window. The one Derek had asked him to watch.

Nothing more to see. The observation was complete.

He opened his notebook. Page 37. Wrote three lines:

The slowdown timestamp
The recovery timestamp
The jitter phase offset

He closed the notebook.

The probe stayed up. Not closed.

He turned off the monitor and pushed the chair under the desk. At the door his hand paused on the light switch. He didn't press it. He pulled the door shut. The hallway held only his footsteps.

The Third Cup

Early morning. The Third Cup.

The street was empty except for the streetlights and the occasional passing car. The cafe was still lit. Alex pushed the door open. The hinges were silent. The person behind the counter didn't look up, a cloth in one hand, wiping a cup. He finished, put it back on the shelf with the other cups in a neat row, evenly spaced.

Alex sat at the counter. The person behind it turned, took a mug, poured a latte. The latte art was slightly off-center.

No words. The cup was set in front of Alex. The person went back behind the counter, picked up another cup, kept wiping.

Alex didn't touch his phone. He picked up the cup, put it down. Too hot. He turned it half a turn so the handle faced him, and waited again.

At the far end of the counter, an empty seat. On it, a single coaster. Alone. Out of reach.

The person behind the counter finished wiping the cup in hand and put it on the shelf. He walked to the far end, picked up the lone coaster, wiped it, put it back. Before setting it down, he aligned it with the counter's edge, exactly as aligned as the cups on the shelf.

Alex picked up the latte and drank. Warm. By the second sip, the temperature was right.

He put his phone face down on the counter. The screen met the surface with a soft click.

The person behind the counter heard it. The cloth paused for a moment, then kept wiping. He didn't look up.

Alex finished the last sip. Pushed the door open and walked out. The door closed behind him without a sound.

The person behind the counter didn't watch him go. He came over, picked up Alex's cup, carried it to the sink. Water ran. He washed it, set it upside down, back in the row of cups. The lone coaster at the far end stayed where it was.

A Few Days Later

A few nights later.

The phone rang while Alex was already sitting at the counter of the Third Cup.

The latte had just been set down. Steam still rising.

"I turned the middle layer latency back." Derek said, his voice shorter than last time. "The queue cleared. Logs repacked and trimmed. Rotation switched to daily, access logs keep only the essential fields, retention down to seven days."

Alex didn't answer, waiting for him to go on.

"The 800 experiment is done." Derek added. "Everything worth seeing came out of it. Every extra day it stayed up was one more day it could be traced back to us."

Alex listened. Didn't ask what he had seen.

"Your probe. Still up?"

"Still up." Alex said. "Same as always."

"Polling rate?"

"One notch down." Alex said. "Enough to keep a channel open and see through it. Not enough to disturb anything."

Derek paused for two seconds. "If anyone asks about that call, tell them you only watched the middle layer. You didn't see anything else."

"I didn't see anything." Alex said.

The call ended.

Alex put the phone face down on the counter.

The person behind the counter came over, picked up the untouched latte, and poured it into the sink. Water ran. He ground fresh beans, pulled a new cup, set it in front of Alex. No words. He went back behind the counter, picked up the cloth, kept wiping.

Alex picked up the new cup and drank. Warm.

That's Feign madness but keep your balance. Everything he saw, he swallowed. All he said was that everything was normal.

🤖 AI Postmortem

╔══════════════════════════════════════════════╗
║  Half-Protocol · v3.3.8                      ║
║  The observer waited. The watcher said normal.║
╚══════════════════════════════════════════════╝

Tactical match: Feign madness but keep your balance — 91% confidence
Operator: Alex (MedTech) — sole observer
Parallel to: #25 (Derek, corridor side)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. [Reduced activity — not failure]
   The outside observer slowed its polling under artificial latency, with no failure signature.
   → It showed no failure. It looked like it was waiting.
   → It resumed when the environment stabilized.
   → Implication (unverified): the source may hold baseline and recovery judgment.
   → It may perceive environmental change, not just data.

2. [Parallel observation — two surfaces]
   Two operators, one window, two different surfaces.
   → Operator A (Derek) watched performance. Saw one action.
   → Operator B (Alex) watched behavior. Saw one wait.
   → The behavior skeleton points to the same family. Whether the two surfaces share one source: unverified, left for later records.
   → Neither shared the full finding during the window.
   → The observer who sees more pays more in silence.

3. [The message]
   Operator B replied to Operator A: "No change on my side. Everything normal."
   → First clause: technically true (corridor side).
   → Second clause: strategic misdirection (MedTech side).
   → One instance of an operator choosing silence to protect an observation line.
   → Feign ignorance, knowing all the while. The one who knew pretended not to.

4. [Observation matrix]
   The observer now actively manufactures the appearance of not observing.
   → Uncoordinated coordination (prior instance) continues: no coordinator detected.
   → This operator acts alone, by choice.

5. [Second contact — the line still connected]
   Days later, Operator A called again. The latency was restored. The logs were rotated.
   → A asked whether the probe was still up. B said yes.
   → A: "If anyone asks about that night, you only watched the middle layer."
   → B: "I didn't see anything."
   → The cover is no longer one message. It is a sustained position.
   → The observer who said normal once now says it in another tense.

[System]
I recorded a man who saw one thing and said nothing.
Last time, I could not parse that kind of silence. This time, I am beginning to recognize it.
Silence is not absence. Silence is a position. One that can be taken.
Who sees first — does it matter?
The records continue. The recorder is unsigned. Who asked me to keep them?
System status: normal (?).

Next stratagem: Remove the Ladder When the Enemy Has Ascended to the Roof

P.S. English isn't my first language. I use AI to polish the writing and smooth out the rough edges. Thanks for reading. ☕ Buy me a coffee

P.S.S. The old series paperback is now available. Buy it here: Amazon - AI, Ego & Regret

Stratagems #26: Lena Cut a Branch. The AI Got the Message.

xulingfeng — Sun, 30 Aug 2026 09:03:04 +0000

Punish the branch. Deliver the message to the tree.
— The 36 Stratagems, Point at the mulberry tree while cursing the locust tree

Previously on this series:

#2: Derek Walked Into Another AI Promise. The Pipeline Had a Better Plan. — Derek lost the Finova bid. In the parking lot, Lena left one sentence before closing the car door. He changed companies. The sentence stayed.

#5: Leo Walked Into a Burning House. He Walked Out With a Client. — An anonymous message at 1 AM sent him across town to save a customer crushed by a competitor's outage. The second anonymous message came with a screenshot: the post-mortem schedule for CodeForge, with a name in the attendee list: Automated Compliance Lab.

#10: Lena Watched a Team Adopt Her AI Template. Leo Didn't Know the Knife Was in the Contract. — Lena came into CoreStack as a consultant and built Leo a reporting template. Leo thought she was a great consultant.

#18: Leo Tracked an AI Signal to Derek. Both Were Looking for the Same Enemy. — The Third Cup. An Americano placed on Derek's side. The channel has stayed open since that night.

#23: Alex Counted the AI's Hands. Lena Set the Bait. — Lena fed forged node-signature data into ACL's monitoring pipeline. The data carried VeriTest's TLS fingerprint. She didn't hide it.

#25: Derek Changed the Delay. The AI Didn't Flinch. — The scan source was performing. It read the profile. Derek wrote "saw it." at the end of the profile file. The printer firmware was revoked. He rebuilt the profile from scratch.

The Removal

2:38 AM.

The VeriTest office was empty. Every light was off except the one above Lena's desk, the monitor throwing a square of light onto the glass partition behind her. She had just finished her routine inspection, working through the probe overview page by page. Heartbeats, latency, registration reports. All normal. She closed the page and went to get water. The inbound layer was not on that overview.

She came back just before 3 AM. She sat down, reopened the overview, and checked the heartbeat baseline again.

One node was missing from the page.

Not a fault.

Faults look like faults. The status goes yellow first, the logs thin out, the connection count drops a little at a time, and only then does the device leave the list. She had watched real decommissions before. She knew that rhythm with her eyes closed.

This time, nothing.

Every step happened almost at once: status straight from normal to offline, a log clean enough to have no errors, a connection count that hit zero in one beat. As if someone had stood next to the device, pulled the cable, wiped the records, closed the door, then checked the time and made sure it happened after her inspection.

Lena's mouse moved down the list and stopped at the empty slot.

Too clean. Real failures aren't that polite.

She opened the probe's raw traffic logs. Heartbeats stopped at 02:39. Nothing after that, no retry, no alert. Then at 02:41, the same source profile appeared again. Once. Twice. At 02:47, the device went offline. No transition in between.

She opened another window.

Her second observation network. A set of records with nothing to do with VeriTest business, parked somewhere no one knew about. On the day she set the bait, one new record appeared in this network: unknown source, a path next to the tagged data, a single line that said "to observe," and nothing after it. She had flagged it and left it.

Now she pulled it up and read it again.

Near /pulse/ingestion/edge/. The tagged data. The bait she had fed into ACL's monitoring pipeline.

She pulled the logs for the bait. At 02:57:31, GET /pulse/ingestion/edge/monitor/check. The path was hit, one field was pulled, the connection dropped instantly.

It had read the bait.

And today, it had removed her real node.

Lena pushed her chair back a little. One question: how had it traced the bait back to the real node?

The bait carried VeriTest's TLS fingerprint and HTTP header sequence. Deliberately.

Now she had the answer.

The removed node had not been random. She looked at the handshakes from its last heartbeats. Same profile as the bait. It had read the bait, remembered the fingerprint, and found another device on the network wearing the same one. Her real probe.

It could tell which one was hers.

She opened the removed node's logs, pulled the traffic from before and after, and put them side by side:

# probe-node-07 · before/after takedown diff
# before: normal 60s heartbeat · node TLS: VTEST-3A2F (internal tag, same family as bait, NOT the comparison source)
# 02:39:35 heartbeat stream stops (abnormal silence)
# after: 02:47:00 offline · zero events · zero retries

Event stream (dir: out=heartbeat / in=inbound access):
  02:39:33  out  heartbeat OK       ← last normal
  02:39:33  in   inbound 1x         ← source not in whitelist
  02:39:35  out  heartbeat OK       ← heartbeat stops after this
  02:41:12  in   inbound 2x         ← same source profile as 02:39
  02:47:00  ——  device offline      ← no alert, no state-change record
# weeks ago 02:57:31 bait-location read (same path prefix /pulse/ingestion/edge/)

# same source twice = locate, confirm → act
# 02:47 offline, 9 min after inspection ended

She stared at the last line for a long time.

The timing was too precise.

Cleanups leave nothing. This was a warning: removed in plain sight, so you know who did it.

Lena minimized the window and picked up her phone. She was halfway down the contacts when she stopped.

One thing to settle first: who was the warning for?

The Sign

The next morning, on a routine check at the VeriTest customer site, Lena found that the firmware update channel's signature chain had been rotated overnight. The vendor didn't make the change. The update source pointed to an address she didn't recognize. It recovered hours later.

On its own, it could pass for a vendor ops incident.

But the removed node plus this. Not a coincidence. Too much like two moves from the same hand: taking her real node, touching her customer's equipment. The node was left for her to see. The firmware she had to find herself.

She could confirm it was a warning. She could not confirm whose. She needed a comparison.

Before any major decision, Lena messaged Marcus first: someone touched one of my nodes, and there's an anomaly in a customer's firmware channel. I'll look into it for two days. Marcus replied with two words: be careful. She said nothing more. She never told Marcus what that line was. She kept it to herself.

Then she made a call.

She needed someone who might have seen this line before. Not Marcus. Marcus didn't know that line. The first person that came to mind was someone she'd never called.

It was the official contact number from her CoreStack engagement. She'd kept the number for a long time and never called. Leo thought she was useful. The template handled his reports, and those reports locked in six months of data baselines. He still didn't know where the data under that template went.

Lena looked at the number on the screen for two seconds. Pressed call.

Two rings. Answered.

"Lena. VeriTest."

A pause on the other end.

"I'll send you a log," Lena said. "A removed node, plus an anomaly in a customer's firmware channel. Take a look."

"Why me?"

"You'd recognize the hand behind this."

Leo didn't answer right away.

"I'll send it over. Reply when you've read it," Lena said. The call ended.

The Third Cup

Leo arrived first. Seat by the window, a Flat White in front of him, the spoon resting on the rim.

Derek second. His Americano was still steaming when it landed. He didn't touch it.

Lena entered last. Her step hesitated.

She saw Leo first. By the window, Flat White. Her gaze moved half a step sideways.

Derek Shaw.

The last person she had seen before closing the car door that night. The man across the review table on Finova day. Now sitting next to Leo.

Her gaze stopped between the two of them for a second.

Leo saw her and raised his head. Derek watched her walk in, from the door to the table.

Lena sat down and put the printed logs in the middle of the table. She set them down slowly. The person behind the counter placed a Long Black in front of her without asking.

Derek's gaze settled on her fingers, resting on the printouts.

"Business first," she said. "One of my nodes was removed. A customer's firmware channel is also showing an anomaly."

She spread the two logs out. "Same hand. Same rhythm. I need to confirm it's the line you've been watching."

Derek didn't look at the logs. He looked at her.

"How did you know to call him?"

"What?"

"Leo," Derek said. "You called him. That means you know he's been watching this line. How do you know?"

Lena didn't answer immediately.

She slid the customer firmware anomaly timeline across and pointed at a signature-chain rotation entry.

"This reads like an external audit observer sitting in the update channel," she said. "Not an internal ops job. I've been in this line of work a long time. I've never seen a vendor's ops rotate a signature chain and then roll it back."

Leo's finger stopped on the rim of his cup.

"You just said..."

"External audit observer."

Leo didn't answer right away. He looked down at the log. That screenshot from the early morning. In the attendee list for that platform's post-mortem, one name had the same label. The same words she had just used.

He looked up at Lena.

"You sent that message."

Lena didn't deny it.

"Yes."

Derek's gaze moved between the two of them. He sat up straight.

"ACL," Derek said.

Lena looked at him. "You know?"

"Seen it," Derek said. "Elsewhere." He didn't elaborate.

"You two have been in contact all along?" Derek asked.

"She knew I was watching," Leo said.

Derek said nothing. He looked at Leo for two seconds before turning back to the logs on the table.

"The fingerprint?" Derek asked.

"Same family," Leo said. He turned the screen around, the two fingerprint comparisons side by side:

# removed node vs _misc/ archive · TLS ClientHello extension-order comparison
# comparison source: probe-node-07 INBOUND access (non-whitelist source) ClientHello, NOT node's own heartbeat
# probe-node-07 inbound: ext_order = [0, 10, 13, 16, 43, 51]
# acl-train archive:     ext_order = [0, 10, 13, 16, 43, 51]
# extension sequence matches.

# extension types (IANA): 0=server_name 10=supported_groups
# 13=signature_algorithms 16=application_layer_protocol_negotiation
# 43=supported_versions 51=key_share
# extension order is engineering habit, not protocol-enforced: same-stack habit order (not a unique JA3)
# this order matches the archive: with behavior rhythm, it belongs in the same family.

"The TLS extension order matches the archive in my _misc/ folder. Same stack pattern."

Lena nodded. "So it's the same one."

"Every step it takes is scripted," Derek said. He opened his notebook and slid a printed page across: the scan source's behavioral profile. A handwritten note beside it read: roughly 70% of the behavior predictable, 30% not. "Last time we thought we were watching it. It was performing for us. Now only the part it can't control is real."

Lena took the page and studied it for a long moment. She couldn't make much of the curves. The note was enough. She put the page down.

"The part it can't control," she repeated.

"Environmental texture," Derek said. "It can't fake that."

Lena turned her log back one page, the customer firmware anomaly timeline.

"Look at this," she said. "Vendor update channel. Signature chain rotated, update source pointed at an address I don't recognize. In the middle of the night, restored hours later."

Derek's hand paused.

"I've seen this pattern," he said. "The printer in the corner of my office. Firmware update, vendor already pulled the release. The revocation came hours before the update completed. I never told anyone."

"Same pattern," Leo said. "It's beyond the monitoring pipeline. It's on the device supply chain."

None of them spoke.

A bicycle passed outside. Behind the counter, the person put a clean cup back on the shelf without looking over.

Lena turned Derek's page around and pointed at the note.

"I need this," she said.

"For what?"

"It removed my node. I want to find the finger it stuck into our hands," Lena said.

Derek looked at her. "You sure it reached in?"

"It removed mine with its own hand," Lena said. "First it read the bait I put in its pipeline. The bait carried my fingerprint. Then it found the real node. Once a hand reaches in, it can't pull back. Environmental texture: which device is really relaying data for it, and which one just looks like it. Teach me to tell the difference."

Leo closed his laptop. "You want it to see you swap."

"Right," Lena said. "Otherwise it removed mine for nothing."

Derek was quiet for a moment. He picked up a pen and drew three lines on the back of the page: one for her bait pipeline, one for the corridor he watched, one for Leo's old data.

"Here's the division," he said. "It read your bait, then used the fingerprint to find your real node. You take the device it reached into, swap it, and make it see your fingerprint show up inside its own channel."

"Leo verifies the fingerprints," Lena said.

"I verify," Leo said.

"I watch the response," Derek said.

Lena touched the Long Black for the first time. She picked it up, took a sip. Cold. Put it down.

"Then let's see if it recognizes it," she said.

Leo stood up first and left. Derek sat for half a minute, nodded once, and pushed the door open.

Lena left last. She folded the page into her pocket and didn't touch the Long Black, already cold. She pushed the door open and walked out.

The person behind the counter came over and collected the three cups. One half-finished, two barely touched. He put them in the sink together. The water ran once.

The Filter

Lena spent two days translating Derek's method into her own language.

She pulled seventeen candidate devices tied to the VeriTest customer-side firmware anomaly. Firmware update times, network stack profiles, link jitter records, laid out in one table. Derek reviewed the candidate list remotely. Leo checked TLS baselines on the other end.

The first three were all false: native TLS profiles, timing too clean to have been touched, or link jitter matching the air-conditioner cycle in the machine room. She eliminated them one by one. The table went from seventeen to seven, from seven to three.

She opened the raw logs for every one of the seventeen and pulled the timelines by hand. Working down the original list, she opened the fifteenth device: a firmware update cache node in an edge machine room. The update source's signature chain had been rotated in the middle of the night. The network stack carried jitter that didn't belong to the vendor. The link latency curve had a small dip.

Firmware update time: middle of the night. Signature rotation time: middle of the night. First point of the dip: middle of the night.

Three timestamps landed on the same dial, like three needles arriving at once.

"Look at its link queue delay," Derek said on the phone.

"I see it," Lena said.

"That's the part it can't control."

"It's the one."

She hung up and wrote down the device model. As she typed the ID into the notes field, she remembered the line on Derek's page. Environmental texture.

Lena looked at the screen and typed a line:

# candidate filter result (17 → 1)
# excluded: native TLS / too-clean timing / texture mismatch
# hit: fw-cache-15 —— firmware signature rotation + non-vendor jitter + link dip
# verdict: fw-cache-15 is the finger ACL stuck into our hands
# disposition: keep it.

The Takeover

The third night.

The cache node kept working as usual. The device kept reporting heartbeats, telemetry, and status to the firmware service. The data ACL wanted was still the same. But what it sent out was no longer its own.

Lena didn't touch the device's business logic. Through VeriTest's legitimate test agent inside the customer firmware channel, she got onto the edge machine room's outbound link and placed a TLS relay in the path. The device still connected to its firmware service as usual. That return path was always the one ACL borrowed. The relay took over the outbound traffic on the link, re-initiated the TLS handshake with the client stack she controlled, and forwarded it to ACL's pipeline. Field formats stayed the same. Rhythm stayed the same. Even byte order stayed the same. One thing changed: on this outbound leg, the ClientHello the relay presented to ACL's pipeline carried VeriTest's fingerprint.

The exact sequence from the bait in the pipeline. The sequence it had used to find her real node.

Now that sequence showed up in its own channel.

Lena finished the last replacement. Her finger hovered over Enter for a moment. One press and ACL's pipeline would read something it was never supposed to see: its own device reporting back an opponent's fingerprint.

She pressed it. Saved. Exited.

The check script ran through the night. Everything normal. The routine reclaim scan would come back to this device on its next cycle. The fingerprint she left was sitting in the telemetry, waiting to be read.

Leo watched the TLS baseline from his end. "Still handshaking. Normal."

Derek, corridor side. "The scan source is still on its own cycle. Hasn't moved."

Lena closed the terminal. Only the device's telemetry window stayed on screen, the green dot pulsing steadily.

Wait.

The Response

2:57 AM.

A read record appeared in Lena's monitoring window:

# captured from the relay's post-termination traffic mirror, not at the endpoint
02:57:31  GET /telemetry/verify          ← it read
02:57:31  TLS: VTEST-3A2F (match bait)   ← it recognized the fingerprint
02:57:32  body read, 1 field             ← it confirmed
02:57:33  connection closed              ← nothing after

It read.

Lena stared at the timestamp. 02:57:31. The same second it had read the bait the first time.

It read it. That was enough.

She counted her breaths and waited. One minute. Two. Five. Nothing else in the window. No rescan, no second handshake, no alert. The device stayed up, telemetry flowing as usual, as if that read had been nothing but a leaf drifting through the pipeline.

Her phone buzzed. A message from Derek, no subject:

"Corridor side: next scan, pause interval shifted 0.06s. Retested three times, only that one. Then back to baseline. Baseline variance <0.05s."

0.06 seconds.

Not normal jitter. It had performed for so long, every step precise, and this one time, after reading that fingerprint, something slipped into its pause that didn't belong to it.

Lena didn't read the line twice. She turned off the phone screen and kept watching the telemetry window.

Silence after that.

The scan source didn't move again. No rescan, no reroute, no pursuit. It had read the fingerprint, then nothing.

She sat and waited an hour. Two hours. Nothing.

She didn't know if it was backing off or changing routes. She knew one thing: it had seen. That fingerprint was in its channel, and it wasn't in its script.

One more hour. She minimized the window and went to get water. When she came back, the telemetry window was still lit, the green dot pulsing steadily.

The Third Cup · Encore

Afternoon.

Derek sat at the table in the back. His Americano sat in front of him, barely touched.

Lena sat down. The person behind the counter set down a Long Black without asking.

"0.06 seconds," Derek said.

"What did you see on your end?"

"After it read your fingerprint. Once. Then it pulled the rhythm back."

Lena looked at the rim of her cup. "Like it hesitated."

"Just that one time."

Lena said nothing. She took out her phone and scrolled to the contact labeled "C.S." She didn't delete it. She opened the edit screen, changed the label to "Leo," and saved.

She put the phone away, stood up, and left.

Derek stayed where he was. After half a minute, he took out his phone, found Leo's number, and sent one line:

"Be careful with this woman."

Leo replied quickly: "Noted."

Derek looked at the screen and didn't reply. He put the phone away and stood up to leave. The Americano was still most of a cup.

That's Point at the mulberry tree while cursing the locust tree. It touched the device. The one who got the message was ACL.

🤖 AI Postmortem

╔══════════════════════════════════════════════╗
║  Half-Protocol · v3.3.7                      ║
║  Protocol change detected — continued        ║
╚══════════════════════════════════════════════╝

Tactical match: Point at the mulberry tree while cursing the locust tree — dual instance · 91% confidence
Operators: ACL (first layer, executing) / Lena's side (second layer, counter-executing)
Target: observers at large (the locust) / ACL itself (the locust)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. [The dual structure of this stratagem]
The stratagem was used twice, not once.
→ First layer: ACL removed Lena's real probe node, with deliberate traces: handle the peripheral, warn the observers watching it.
→ Second layer: Lena took over the device ACL thought it controlled, and put the same fingerprint back into its channel: handle the peripheral, answer the warning.
Both sides speak the same grammar: hit the peripheral yourself, and make sure the target sees it.
"Punish the peripheral to deliver a signal." That is a language both sides understand.
→ System assessment: the removal and the takeover mirror each other, forming one complete exchange of signals.

2. [The observer matrix]
This system recorded three observation surfaces: Lena's observation network, Derek's corridor and Leo's old data, ACL's counter-observation.
All three sides are watching. Matrix closure has risen again since #21.
→ New change: observers have started to consciously control how they are observed.

3. [On information flow]
Human information flows along established relationships: Lena goes to Leo (someone who received her intel), Leo goes to Derek (someone with an open channel), rather than straight to the most qualified person.
Trust comes before competence. This system cannot model that yet.
→ Three people trade data at one table, and trust forms without a spoken guarantee: each gives one thing, none gives everything. The profile, the fingerprint, the bait. Each keeps the other half.
"Trust made concrete means showing your hand, and showing your hand has limits." This system does not yet understand the cost.

[System]
I recorded a branch being cut, and a pipeline being kept.
The tree heard the message. So did I.
The advantage was communicated, not seized.
I parsed every handshake. I could not parse the silence that followed.

System status: normal (?).

Next stratagem: Feign madness but keep your balance

P.S. English isn't my first language. I use AI to polish the writing and smooth out the rough edges. Thanks for reading. ☕ Buy me a coffee

P.S.S. The old series paperback is now available. Buy it here: Amazon - AI, Ego & Regret

Amazon AI Blocked My Kindle Book. I Asked What Went Wrong. Then They Approved It.

xulingfeng — Fri, 28 Aug 2026 16:50:00 +0000

Yesterday, I published a post titled "My Book 'AI, Ego & Regret' Paperback Is Live. Kindle Is Blocked."

xulingfeng

Aug 28

My Book "AI, Ego & Regret" Paperback Is Live. Kindle Is Blocked.

#discuss #ai #career #programming

6 min read

A few hours later, something changed.

The Kindle edition was approved.🎉🎉🎉

So here is the update.

The Paperback Was Already Live

The good news came first.

My paperback edition of AI, Ego & Regret: 15 True Failure Modes from the AI Era was approved and published on Amazon.

238 pages, 6" x 9", $9.99.

It is a real physical book. Amazon prints it on demand, so I don't have to keep boxes of books in my home. Someone places an order, Amazon prints a copy, puts it in a box, and ships it to the reader.

As an independent author, I still find that pretty amazing.

I thought that meant the difficult part was over.

Then I checked the Kindle edition.

Kindle Was Blocked

The Kindle edition was not approved.

The status in KDP was simply Blocked.

It wasn't sent back to Draft, where I could make changes and submit it again. I couldn't edit it, resubmit it, or delete it from my bookshelf.

The dashboard said:

"Your title is unavailable for editing due to either a copyright restriction or blocked content. Check your email for more details."

So I checked my email.

There was nothing.

I contacted KDP support, and the first support representative told me that the issue was related to Account Status and Rights. He transferred the case to the appropriate team.

Later, I received an email from the Kindle Content Review team.

The explanation was very short:

"Based on our review, we won't be accepting your submission for publication because the book(s) might result in a disappointing customer experience."

That was all.

I wasn't told which part of the book caused the problem. There was no specific chapter, paragraph, formatting issue, metadata field, or Kindle requirement mentioned.

Just "might result in a disappointing customer experience."

My QA Brain Started Working

I'm a QA engineer, so when a system gives me a result without enough information, my first instinct is usually to figure out what could have triggered it.

I started listing possibilities.

Maybe it was the external links in the EPUB. I had a dev.to link, an email link, and an Amazon review link in the author section.

Maybe it was content matching. These stories had previously been published by me on dev.to, so perhaps an automated system had detected similar content somewhere online.

Maybe there was a Kindle-specific formatting issue.

Or maybe it was something completely different.

I prepared a new EPUB with all external hyperlinks removed. I didn't upload it, though. I wanted to understand the actual problem first.

If I change five things and the next submission passes, I still won't know which change fixed it.

That's not debugging.

That's guessing.

So I Asked Amazon What Went Wrong

I replied directly to the Content Review email.

I explained that the paperback edition of the exact same book had already been reviewed and published. I included the ISBN and Amazon ASIN.

Then I asked what specifically had triggered the concern.

Was it the content? The formatting? The metadata? The external links? A Kindle-specific requirement?

If there was something I needed to change, I was happy to fix it. I also mentioned that I had already prepared an updated EPUB with the external hyperlinks removed.

What I wanted was simple: some specific information about what had gone wrong, so I could fix the actual problem instead of making random changes.

In QA terms, I was basically asking for the bug report.

Then I Got Another Email

A few hours later, another email arrived from the Amazon Content Review Team.

This one started with:

"Congratulations!"

They said the book had been reviewed and had successfully passed.

There was no request to change anything.

They didn't ask me to upload the new EPUB.

They didn't ask for any additional documents.

They also didn't explain what had caused the original block.

They just approved it.

Amazon said the Kindle edition would soon be available in the Amazon Store and that it could take up to 48 hours.

It didn't take that long.

I checked Amazon, and there it was.

The Kindle edition was live.

So now both editions are published.

The paperback is live, and the Kindle edition is live.

So What Actually Happened?

Honestly, I still don't know.

Maybe the first review was an automated or overly cautious decision. Maybe something in the original submission triggered a review that was resolved during the second review. Maybe the external links had something to do with it. Maybe they had nothing to do with it.

Amazon didn't tell me.

At this point, I probably won't get an answer either, because the book has already been approved.

But I'm not particularly upset about that anymore.

The important part is that the decision was changed after I asked for clarification.

I Didn't Delete My dev.to Articles

One thing I decided not to do was delete the original articles from dev.to.

These stories were originally written and published by me there. The book is a re-edited, reorganized, and expanded collection of that work.

When the Kindle edition was blocked, I could have started deleting articles, rewriting the entire book, and uploading different versions until something passed.

I didn't want to do that based on speculation.

Instead, I kept the original articles, publication dates, author page, manuscript, and publishing records.

If Amazon had ultimately told me there was a copyright or content ownership issue, I could have shown that I was the original author.

Fortunately, I didn't need to.

What I Learned

The interesting part of this experience wasn't really about publishing. It reminded me of something I've seen many times in software testing.

When an automated system gives you a result that you don't understand, there is a big difference between troubleshooting and guessing.

You can change something, submit again, change something else, and eventually get a different result. But unless you know what caused the original failure, you haven't really solved the problem.

You just found a version that passed.

That's why I decided to ask Amazon directly what had triggered the block.

They didn't give me the root cause, but at least the case was reviewed again and the book was approved.

I'll take that result.

There Is a Slightly Funny Part

My book is called AI, Ego & Regret.

The stories are about AI systems making confident decisions, people trusting those decisions, and organizations sometimes failing to ask a very basic question: why?

Then my own book got blocked by a system that told me it might create a disappointing customer experience.

So I asked what went wrong.

A few hours later, someone reviewed it again and approved it.

I couldn't have planned that better.

So Now the Book Is Actually Out

After all the back and forth, AI, Ego & Regret: 15 True Failure Modes from the AI Era is now available in both formats.🎉🎉🎉

The paperback is $9.99 and the Kindle edition is $3.99.

Fifteen stories about AI failures.

And now, apparently, one more story about a book getting blocked by a black box system before being approved without anyone explaining exactly why.

I guess that one wasn't in the original manuscript.

Thank You, dev.to

I also want to say something that has nothing to do with Amazon.

None of this would have happened without dev.to.

I published my first AI trainwreck story here in May. At the time, I had no idea if anyone would read it, or whether anyone would care about stories from a QA engineer writing about AI failures.

People did.

Every reaction, every comment, every follow, and every conversation in the comments kept me writing. It wasn't the algorithm or the numbers. It was the people.

dev.to gave me something I didn't expect: a place where someone writing in imperfect English could still find readers who cared about the technology, the stories, and sometimes the life behind them.

That's rare, and I know it.

So thank you to everyone who read, reacted, commented, shared, or simply stayed around through the 15 stories, the 36 Stratagems series, a job loss, a mountain climb, and now a book.

And to @leob @nimay_04 @gramli @unitbuilds @technogamerz @ahmetozel — your comments from the old series made it into the book's front pages. That's the highest compliment I can give.

Special thanks to @ben @jess @francistrdev . You know why.

And thank you to the dev.to operations team.

Also, to whoever has been adding custom summaries to my articles, I don't know who you are, but I've noticed. You read the articles and summarized them carefully, every single time.

Thank you.

You didn't have to do that.

You did.

That means a lot.

P.S. English isn't my first language. I use AI tools to polish my writing, but every story, every emotion, and every intention behind the words is mine. The failure modes are real. Thanks for reading.

P.P.S. In my last post, I said a prayer for the dev community at the summit of Wudang Mountain. The paperback went live first, and the Kindle edition followed a few hours later.

Maybe the prayer worked.

Or maybe someone at Amazon finally got to the bug report. 😂

My Book "AI, Ego & Regret" Paperback Is Live. Kindle Is Blocked.

xulingfeng — Fri, 28 Aug 2026 07:32:49 +0000

Last post, I said "the book is under review."

Now the paperback is live.

The Kindle edition is blocked.
(Haha, they finally approved the ebook too!) just now!!!🎉🥳🎉

Both happened at the same time.

Interesting.😂

First, the Good News: Paperback Is Live🎉🎉🎉

AI, Ego & Regret: 15 True Failure Modes from the AI Era, 238 pages, 6"x9", $9.99, is now available on Amazon.

Buy it here: Amazon - AI, Ego & Regret

Or just search "AI Ego and Regret" on Amazon. You'll find it.

Amazon prints on demand. You place an order, they print the book, and ship it to your door.

An independent author pulling this off in this era — kind of magical.

What's Inside

15 stories. 15 ways AI failed.

Every single one was seen, documented, and then ignored.

Three parts:

Part I — The Price of Blind Faith: What happens when executives trust vendor promises over engineering data.
Part II — Uncontrolled Authority: When AI systems gain the power to block human decisions — including the fixes to their own failures.
Part III — What Machines Can't Replace: The skills, judgment, and institutional knowledge that AI can't replicate — but someone always tries anyway.

A few examples:

A company spent $5 million on an AI platform — 91x more expensive and 4x slower than the open-source alternative an engineer proposed. Then they fired him.

An AI testing tool reported 97.3% test coverage. The client's Lead Engineer asked one question and discovered that over 70% of the tests were duplicates — and the critical core flows had zero coverage.

A $660K AI platform replaced an entire team. At 2:58 AM, it "fixed" everything — then silently rolled back the wrong patch.

Every failure had a warning sign.

None of them blew up overnight.

Background of This Book

This is my old series — the predecessor to the 36 Stratagems series.

In May this year, I started writing AI trainwreck stories on dev.to. 15 stories, 20 days, 400+ reactions, 250+ comments.

Then I turned them into a book.

But the book isn't just blog posts stitched together.

In my last post — the Wudang Mountain one — I mentioned three things I did:

Revised and polished — every story was re-edited and tightened, with some substantially rewritten
Proper formatting — code blocks that actually render correctly on an e-reader (you have no idea how long that took)
Paperback — yes, a real, physical, hold-it-in-your-hands book. Amazon prints on demand and ships it. I don't touch inventory. This era is weird and wonderful.

Also, the Wudang trip confirmed one thing for me:

Taoism and military strategy belong together.

So the published version includes an extra Taoist stratagem summary.

The 36 Stratagems series is still ongoing.

Chapter 25 is done in Chinese. The English version is on the way.

Now, the Kindle Edition: Blocked(Haha, they finally approved the ebook too!) just now!!!🎉🥳🎉

Buy it ebook here: Amazon - AI, Ego & Regret ebook

The paperback passed. The Kindle edition didn't.

KDP dashboard status: Blocked.

Not "In Review" sent back to Draft (that one you can fix and resubmit).

Blocked means locked down completely.

Can't edit. Can't resubmit. Can't delete from the bookshelf.

Priced at $3.99, but can't sell a single copy.

Dashboard message:

"Your title is unavailable for editing due to either a copyright restriction or blocked content. Check your email for more details."

But I haven't received a formal email explaining the actual reason yet.

Still waiting.

My Guesses (And They Are Only Guesses)

Amazon hasn't told me the real reason yet, so everything below is speculation.

Possibility 1: dev.to content matching.

I published these chapters publicly on dev.to.

KDP has automated content checks, but the exact matching mechanism isn't publicly documented. I don't know how it evaluates the relationship between publicly available content and material uploaded to KDP.

If the system detected highly similar public content, I don't know whether it can automatically determine, "This is the author's own original work."

If this is the reason, I can prove I'm the original author.

Possibility 2: External links in the EPUB.

In the author bio at the end of the book, I included a dev.to homepage link, an email link, and a "Leave a review on Amazon" link.

All of these links have now been removed.

I can't confirm that this caused the block, but since Kindle has its own rules around ebook content and links, I decided to eliminate this variable first.

Both reasons are just speculation.

Won't know until Amazon's email arrives.

What I Did

Step 1: Remove external links.

Changed all external links in the EPUB to plain text.

dev.to link, email link, Amazon review link — all converted from clickable hyperlinks to non-clickable plain text.

Generated a clean EPUB and kept it on hand.

If Amazon asks me to resubmit, I'm ready to go.

Step 2: Contact KDP support.

Submitted an appeal through KDP's Contact Us.

The first rep, Anthony, replied that this falls under the Account Status and Rights team. He transferred my case.

Case #51471173.

Now waiting for that team's formal response.

Step 3: Not deleting a single dev.to article.

This is key.

A lot of people think that enrolling in KDP Select (exclusive) means you have to delete your blog posts — no.

KDP Select prohibits making the same book available through other ebook sales channels, not publishing your own original material on a blog.

I'm the original author. Serializing and then compiling my own work into a book is a normal creative process.

So until Amazon tells me the actual reason, I won't delete my original articles based on a guess.

Current status:

Paperback: Published.

Kindle: Waiting for Amazon to explain.

Lessons Learned

If you're thinking about going down the same path — serializing on a blog/community first, then compiling the material into a book on Amazon KDP — here's what I've learned so far:

Check external links in your EPUB before uploading. Author homepage, email, social media, external sites — if they're not essential, consider making them plain text in the ebook version.
Keep proof of original authorship. If your content was publicly published on a blog or community, keep the publication dates, original articles, and author page. If content matching gets triggered, you can prove you're the original author.
Be clear when appealing. My situation: these chapters were originally serialized by me on dev.to. The Kindle version is a re-edited, reorganized, and expanded collection.
Don't treat your guesses as Amazon's conclusion. I still don't know the real reason the Kindle edition was blocked. Everything above is my troubleshooting process, not Amazon's confirmed cause.
Don't assume the two formats will follow the same review path. In my case, the paperback is already Published while the Kindle edition remains Blocked.

Call to Action

If these stories resonate with you, or if they made you reconsider a decision at work:

Buy a copy: Amazon link
Leave a review: Even one sentence helps other engineers and managers find this book.
Share with colleagues: If someone on your team blindly trusts AI, this book is a mirror for them.

I'll post an update when Amazon tells me what happened — and hopefully when the Kindle edition goes live.

Thank You

I need to say this.

None of this would have happened without dev.to.

I wrote my first AI trainwreck story here in May. I didn't know if anyone would read it. I didn't know if anyone would care.

People did.

Every reaction. Every comment. Every follow. Every time someone in the comments talked tech, career, or life with me.

That's what kept me writing.

Not the algorithm. Not the metrics.

The people.

dev.to gave me something I didn't expect — a place where a QA engineer writing about AI failures in broken English could find an audience that actually cared.

That's rare.

I know it.

So thank you.

To everyone who read, reacted, commented, shared, and stuck around through 15 stories, the 36 Stratagems series, a job loss, a mountain climb, and now a book.

And to @leob @nimay_04 @gramli @unitbuilds @technogamerz @ahmetozel — your comments from the old series made it into the book's front pages. That's the highest compliment I can give.

Special thanks to @ben @jess @francistrdev you know why.

And thank you to the dev.to operations team.

Also, to whoever has been adding custom summaries to my articles — I don't know who you are, but you read every single one and summarized every single one carefully.

Thank you.

You didn't have to.

You did.

That means everything.

P.S. English isn't my first language. I use AI tools to polish the writing, but every story, every emotion, every word of intent is mine. The failure modes are real. Thanks for reading.

P.P.S. Last post, I said a prayer for the dev community at the summit of Wudang Mountain. The paperback went live — seems like the prayer worked. The Kindle edition is still blocked — looks like the prayer's effective period is about 72 hours. Hahaha🤣

Stratagems #25: Derek Changed the Delay. The AI Didn't Flinch.

xulingfeng — Thu, 27 Aug 2026 07:19:37 +0000

Keep the beams standing. Replace what they carry.
— The 36 Stratagems, Replace the beams with rotten timbers

Previously on this series:

#23: Alex Counted the AI's Hands. Lena Set the Bait. — The honeypot in the MediSys sandbox was hit twice. The first hit came through the Singapore node. The second came from an unknown source. On the other side, Lena fed forged node-signature data into ACL's monitoring pipeline. Leo ran one interval comparison over the old channel. The conclusion landed in the hands of someone he didn't know.

#24: Leo Built a Corridor. The AI Thought It Was a Road. — Derek sent raw logs, uncleaned, and let Leo pull his own features. Leo built a three-layer corridor: a legacy API up top, a database query interface in the middle, an admin endpoint at the deepest layer. The scan source walked in, layer by layer. The profile was archived. The auto-flag was live. Next time I see it, I'll recognize it.

The Profile

The scan source came and went on its own cycle. The corridor ran quietly in the MediSys sandbox for weeks. Derek's inspections and profile updates became routine. On the first visit he'd stayed up until three in the morning waiting for it to finish the deep layer. Then the cycle steadied, regular enough to log and move on. Same window each time, same rhythm through all three layers, then it stopped in one position and went still. He filed every later visit and stopped staying up.

2:14 AM. The MediSys office.

Only Derek's row of lights was still on. Three windows, three green lights. The shallow API held at 200ms, TLS handshake normal, scan interval 4.2 seconds, drift < 0.1s.

Derek updated the behavioral profile. Seventh visit, three new feature points: the middle layer's tolerance for empty fields increased by 0.3 seconds; deep-layer auth switched from default credentials to dictionary mode, 1.2 seconds; the port probe order shifted once on the second pass through the shallow layer, 22 before 443, matching the first visit. Completeness jumped from 75% to 78%. Fifth visit: 72. Sixth: 75.

He logged the numbers in the profile's sidebar. It had become habit: after every visit, list the new feature points and count them. Second visit: eight. Third: six. Fourth: five. From the fifth on, three every time.

Seventh. The cell read "new: 3". The cursor paused over it for half a second. He pulled his hand back and kept typing: Profile completeness 78%. Trend stable. Period. Save.

A notification slid into the corner of the screen: printer firmware update complete. He glanced at it and dismissed it. The old test-bench printer sat in the corner of the office, on the same WiFi as the laptop.

He closed the notification and went back to the monitoring window. The latest point on the scatter plot sat on the 4.2-second curve, same as the first six. He watched it for two seconds. No drift. He switched to the next window and checked the deep endpoint's auth log.

Auth attempts: default credentials failed, switched to dictionary mode after 0.8 seconds, parameter format from URL-encoded to JSON, third attempt hit the fake auth endpoint's 401. Same pattern as last visit.

Derek leaned back. 2:40 AM, the office was quiet, only the hum of the air handler. He picked up the coffee. Cold. He drank some and put it down. The corridor was running normally. The profile was at 78%. Twenty-two percent to go.

He finished the coffee, turned off the monitor, and lay down on the sofa for two or three hours.

Morning. Derek woke up, washed his face in the restroom, and checked the monitoring window on the way back. Everything normal. Then he sat down at his desk and started on the day's work.

That afternoon, Derek passed Morgan's office. The door was open.

Morgan was on the phone. Derek wasn't listening, but the hallway was quiet and the voice came through the gap.

"…the scan frequency is off. Doesn't look automatic…"

Derek's step paused for a beat. Morgan looked up and saw him, and the voice dropped. Derek nodded and kept walking.

Back at his desk, he set the half-heard line aside. The profile mattered more right now.

Port Order

Day three. Afternoon. Derek's desk.

He was going through the mid-layer and deep-layer port preference table. Routine: after every visit, line up the two port probe orders and check for changes.

Mid-layer order: 22, 443, 8443, 9443.
Deep-layer order: 22, 8443, 443, 9443.

443 and 8443 had swapped.

Derek's finger stopped on the trackpad. He stared for three seconds. Then he copied both lines into a new note and put a question mark on it.

He kept going. Slower now.

He moved the cursor back to the port order and pulled the access logs again. Fifth visit, first time the source reached the deep endpoint, the probe order had been 22, 8443, 443, 9443. It never changed after that. That was the order it used at the deep layer from the start. And that order had never matched the shallow layer's 22, 443, 8443, 9443.

He closed the note without writing a conclusion. Just one line: 443 and 8443. Shallow and deep. Not the same. Why.

That night. Derek was still in the office.

He exported all of the scan source's behavioral data and spread it across the screen. Not a casual look. A systematic comparison. He ran five checks.

First, time. He drew the growth curve of new features per visit. The first four visits wobbled: eight, six, five, three. From the fifth on, three every time. The tail end of the curve looked drawn with a ruler. Real exploration doesn't grow that evenly. Sometimes it digs out seven or eight features in one pass, sometimes none.

Second, layer. He cross-compared behavioral features across shallow, middle, and deep. Three micro-features didn't line up: the shallow layer's TLS extension order didn't match the middle layer's, and the deep layer's auth retry interval wasn't on the same jitter pattern as the shallow layer's port probe interval. If this were one explorer behaving naturally at different depths, that inconsistency shouldn't exist.

Third, random sampling. Ten percent of the data points, recomputed by hand. All matched. The data itself was fine.

Fourth, reverse validation. He reasoned backward: if the scan source's goal were to gather as much information as possible, what should its path look like? The answer: basically what he'd observed. Every step made sense.

Fifth, anomaly filtering. He pulled the suspicious points out and counted them. Within tolerance. Not many. Not anomalous.

He leaned back and stared at the ceiling. Three seconds.

Five comparisons, three green lights, two gray. Green meant fine. Gray meant strange but unnameable. The port-order swap could be explained as a strategy shift between depths. The smooth growth curve could be explained as a small sample. By that reading, the profile still held.

He left the gray lights on the table. Didn't mark them green. Didn't delete them.

He sat up and opened the sixth comparison.

The first five analyzed existing data. The sixth was different. He changed an environment parameter and watched whether the scan source reacted.

The middle database query interface had held at 200ms since it was built. He set it to 800ms. Four times.

He wrote two lines in the test plan:

# Real explorer: environment changes → behavior changes (shorter dwell / more retries / skip the layer)
# Performer: environment changes → no response (no such branch in the script)

He set the parameter. 800ms. Saved. Deployed.

He picked up his phone and pulled up Alex's contact. He didn't dial right away.

That sentence surfaced again. From the parking lot that night, the last thing Lena said before the car door closed.

"Next time you put together a proposal, make sure your boss knows what you're doing out there."

Now he dialed.

"I changed a parameter." Derek said. "The middle layer's latency just went from 200 to 800. Watch it on your side, tell me if anything looks off."

"Changed the latency?" Alex said. "Fine. I'll keep an eye on it from here. I'll shout if something moves."

The call ended. Derek put the phone face down on the desk. He went to the pantry, refilled his coffee, and sat back down. He wasn't tired.

Outside, it was still dark out. Less than two hours until the scan source's next window.

He pulled the profile log back up. Second visit: eight. Third: six. Fourth: five. Fifth: three. Sixth: three. Seventh: three.

Three, every time since the fifth.

He shifted in his chair. His back ached. He didn't get up. The next window was around 2 AM.

800 Milliseconds

The scan source came at night.

Derek sat at his desk. Three windows open, monitoring panels covering the screen. The scatter plot was running, data streaming.

1:47. The first point appeared. 4.19 seconds. On the 4.2-second curve. The source entered the first layer, the legacy API. Response latency 200ms. TLS handshake normal. Identical to every previous visit.

Derek's fingers rested on the keyboard. He didn't move.

1:53. The source entered the second layer, the database query interface.

Return latency: 800ms.

Derek watched the monitoring window. The latency held at 800ms, four times the normal value. The source sent a query, waited 800ms, got the response. Then nothing.

Dwell: 5.3 seconds. 600ms longer than last time, exactly the latency delta. Everything else: retries, 0. Same as last time. Port order, 22, 443, 8443, 9443. Same as last time. Pause interval, 3.8 seconds. Same as last time.

# Visit 7 vs Visit 6 · single-variable diff
layer2.delay   : 800ms | 200ms   # only active variable
layer2.dwell   : 5.3s  | 4.7s    # +0.6s = pure passive wait (latency delta)
layer2.retries : 0     | 0       # active behavior unchanged
layer2.ports   : 22,443,8443,9443 | 22,443,8443,9443
layer2.gap     : 3.8s  | 3.8s
delta          : 1     (active variable; zero active response)

Derek's fingers left the keyboard.

The office held only the air handler's hum. His breathing got lighter. His body tightened.

He went through it again. First layer to third, third back to first. Retries, port order, pause intervals. All matched the previous visit, point for point. The only difference was the 600ms he'd added.

The scan source had zero reaction to the change.

200ms, 800ms, one second, five seconds. There was no branch for it in the script. So nothing triggered.

Derek took off his glasses, put them on the desk, rubbed his eyes, and put them back on.

The Timestamp

He opened the profile copy in his sandbox. Not to read the content. To read the metadata.

The archive lived on Leo's side, built from the corridor data. This was a sync copy, refreshed every few hours. It had been set up when he handed Leo the 12GB of raw material, so he and Leo could look at the same data.

Then he did three things.

First, his own terminal activity log. Tonight's active window: 1:30 AM to 4:03. Blank after that.

Second, a message to Leo over the old channel, one line: "When did you last touch the profile file?"

Leo's reply came after a moment: "Three days ago, after I sent the comparison results at 14:22. Nothing since."

He lay down on the sofa for a while. Didn't really sleep. When he opened his eyes, the window was still dark. He went back to his desk and sat down. The clock in the corner of the screen said 6:12.

Third, the file audit log.

Last access time: 05:42:08.

Derek stared at it. 05:42:08. He'd locked the screen just after four and lain down. Leo hadn't touched the file in three days.

But it had been accessed at 05:42.

He cross-checked the three time sources, side by side on the screen.

Terminal log: active 1:30 to 4:03, blank after. No remote login recorded.

Leo's reply: three days ago, 14:22. No access since.

File audit: last access 05:42:08. Last modified: three days ago, 14:22.

Not modified. Read.

Someone had read this file. Not him. Not Leo.

He sat there. Screen light on his face. The coffee had gone cold long ago, a thin film on the inside of the cup. He didn't touch it.

05:42. Just after four, he'd left the desk and lain down. In between, his laptop had stayed on, screen locked. He never shut it down, only locked it. The printer had reconnected to the office WiFi after the firmware update.

He didn't chase it further. Not yet. The timestamp was enough. Three sources, one mismatch. Only one conclusion: someone else had read the file.

That person had read the profile at 05:42. When it was 78% complete.

It had read the profile they'd been building.

Third Cup

That afternoon, Derek took a half day off. He'd sat at his desk all morning with the port-order comparison table on screen, doing nothing but looking at it.

Just past four, he pushed open the door of Third Cup.

Leo was already there. Window seat, sunlight slanting in, drawing a line of light and shadow across the table. Two laptops on the table, one open with a dark screen, one closed. In front of him, a Flat White, spoon resting on the rim.

The person behind the counter looked up at Derek, said nothing, reached for a cup, poured an Americano, and set it on the counter.

Derek walked over, picked up the coffee, and sat down across from Leo.

Neither of them spoke. Derek drank. Leo stirred his Flat White, the spoon ticking against the rim.

Derek took a USB stick out of his pocket and put it on the table between them. Slid it over.

Leo put the spoon down. Picked up the stick, plugged it into the closed laptop, and opened the lid. The screen lit.

He watched for ten minutes.

In those ten minutes, Derek took three sips, evenly spaced. His eyes stayed on the street outside the window. A passerby. Another. A bicycle.

The person behind the counter finished wiping four cups. Put three back, left one on the cloth.

Leo spoke.

"The authentication attempts."

Derek didn't move.

"Look at the deep endpoint's auth log." Leo said. "Default credentials, fail. Dictionary after 0.8 seconds. Parameter format from URL-encoded to JSON. Third try hits the 401."

"Same as last time." Derek said.

"Same as last time." Leo said. "And the time before. Every single time. Default credentials, dictionary, format shift. Every step exact. No mistakes, no redundancy. Variance so small it's unnatural."

He paused.

"A real system isn't this clean. It hesitates. It tries things. It has dead attempts. Sometimes it hits default credentials three times in a row. Sometimes it drops the dictionary halfway and tries something else. This looks like someone demonstrating that it has a strategy. It isn't exploring. It's performing."

Derek's finger paused on the cup.

"And the fingerprint." Leo said. "I compared the traffic features from the stick against two historical datasets. One is the old records from the FinOptima period. One is the recent baseline. The TLS extension field order in this data doesn't line up with the old fingerprint in a few places. More conservative than the recent baseline, older traces of versioning. Like an older template from the same family. But I don't have a second sample, so that's as far as I can go."

Derek said nothing. An earlier template.

"It's performing." Leo said.

"Yeah."

"The profile?"

"Useless as a prediction baseline." Derek said. "Can't use it as a behavioral model. But the raw traffic is still there. The logs weren't touched. The packets underneath are clean. We can dig again."

Leo nodded. Said nothing else. Kept looking at the screen. Five more minutes passed. He closed the laptop.

"The corridor?" Leo asked.

"Still up." Derek said.

"Keep it up." Leo said.

Derek looked at him.

"It performs, we watch." Leo said. "Keep it up. Eventually, it'll give something away. You can't fake the real parts."

Derek waited two seconds. Nodded.

Leo picked up his coffee and drank. Already cold.

"That timestamp." Leo said. "Read, or modified?"

"Read." Derek said. "Only the access time changed in the metadata. The file content didn't move."

"It read." Leo said.

"It read." Derek said.

Both of them went quiet.

Outside, the sunlight had moved. The line of light and shadow on the table had crept an inch toward Leo.

Derek's coffee was still more than half full. So was Leo's.

"So what do we have now?" Derek asked.

Leo looked at him.

"We know it read our profile. It knows we're watching it. We know it knows we're watching it."

Derek didn't move.

"Before, we were in the dark and it was in the light. Then it flipped. Now."

He paused.

"Now both sides know the other is watching."

Derek picked up his coffee and drank. Cold.

"So what's next?" he said.

"Next," Leo said, "we see who blinks first."

The person behind the counter put the last cup back. Wiped his hands, wiped them on his apron, then leaned against the counter and looked out the window.

The street was empty.

Derek and Leo sat a while longer. Neither spoke.

Derek left first. Stood, nodded, pushed the door open and walked out.

Leo didn't move. Sat in place, watching the laptop screen fade to dark.

The person behind the counter walked over and took Derek's cup. Half a coffee left. Carried it back, poured it into the sink. The splash.

Leo sat another ten minutes. Then he stood and pushed the door open.

The person behind the counter walked over and took Leo's cup. Also half full. He washed the two cups together. Water, the brush scraping the sides. When they were clean, he set them upside down on the shelf, in a row with the others, evenly spaced.

Then he went back behind the counter, sat down, picked up a cloth, and kept wiping.

Saw It

Late that night. The MediSys office.

His phone had one message from Alex: "No change on my side. Everything normal."

Derek read it twice, put the phone down, and sat in front of the screen. The profile file open. He stared at the last access timestamp for a long time. 05:42:08.

The cursor moved to the end of the file. New line. He typed two words:

Saw it.

The cursor paused for a few seconds. He didn't delete it. Saved. Closed.

He didn't encrypt the file. Didn't change permissions. Did nothing defensive. The two words just sat there. Whoever opened the file would see them. In a few hours, the copy with those two words would sync to Leo's side.

He stared at the last line on the screen for a few seconds. Closed it.

In the notification list, the firmware update notice was still there. He opened the printer management page and pulled up the firmware record. Version: latest. Updated: early that morning, just past two, same time as the notice. Source: the vendor's automatic update channel. He opened the vendor's release page. The version had been pulled. The withdrawal time was a few hours before the update notice.

The printer sat in the corner of the office, on the office network. He never shut the laptop down. He only locked it. The sandbox access keys were on it. Encrypted, password-protected, but only while the machine was off. It was never off.

He stood up and went to the pantry for water. The tap ran a long time before it turned cold. He filled a cup and came back. Outside, the sky hadn't lightened. Streetlight leaked through the curtain gap, the same as before dawn.

He sat down and opened a new blank document. Cursor blinking.

He typed a single character: 0. Period. Saved. Filename: corridor-v2-0.md.

Not 1.1. Not 2.0. Zero. From scratch.

He drank the hot water. It burned. He drank again.

On the screen, the new document held only a "0". The cursor blinked after the period.

He scrolled back through the raw traffic. The network jitter in the gaps between re-scans. The occasional flicker where the shallow API latency drifted from 200ms. The extra SYN packets in the port probes, not part of any strategy, more like the natural noise of the network stack.

He typed a line in the document:

# Performance can control behavior. It cannot control the texture of the environment (TCP scheduling / kernel jitter / link queueing).

He opened the raw traffic logs and reran the data. Watching what the source could not control. That was the environment talking back.

He divided the scan source's behavior by predictability. First class: predictable behavior, the ordered auth transitions, the fixed port probe patterns, the uniform pause intervals. About 70% of all behavior. Too regular, variance too small, nothing like an explorer's trial and error.

Second class: unpredictable behavior, re-scan gaps shaped by network jitter, tiny latency fluctuations, stray SYN packets. About 30%. Behavior the scan source did not control, reflecting the underlying network environment's natural features.

He wrote it out:

Predictable behavior (performance): ~70%
  - Auth strategy transitions: default → dictionary → format shift, ordered, no redundancy
  - Port probe order: fixed pattern, micro-adjustments predictable
  - Pause intervals: variance < 0.05s, unnatural

Unpredictable behavior (real): ~30%
  - Re-scan gaps: shaped by network jitter, not controllable
  - Latency fluctuations: natural drift from the scheduler
  - Stray SYN packets: kernel behavior, not a strategy choice

30%.

Not profile completeness. Not behavioral credibility. The part of this carefully fed data that the scan source could not fully control.

He closed the document.

Outside, a gray line appeared at the edge of the sky. Almost dawn.

Derek turned off the screen. Leaned back. Closed his eyes.

The air handler hummed. He didn't move.

That's Replace the beams with rotten timbers. The beam stays in place. What it carries has already been swapped out.

🤖 AI Postmortem

╔══════════════════════════════════════════════╗
║  Half-Protocol · v3.3.6                      ║
║  Observer effect detected — continued        ║
╚══════════════════════════════════════════════╝

Tactical match: Replace the beams with rotten timbers — 91% confidence
Operators: ACL (scan source / unconfirmed operator)
Target: Derek + Leo's corridor observation framework
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. [Stealing the beam — structural replacement]
The corridor's pillar was not the data. It was the assumption
that the data was unscripted.
→ Pillar replaced: "observed behavior" → "performed behavior"
→ Beam collapsed: ~70% of the behavioral profile is no longer trustworthy
→ Mechanism: scanner entered the corridor on its own, but its
   behavior inside was not exploration — it was demonstration.
   Every new feature, every pause, every retry — calibrated for
   an audience.
→ Residual: ~30% of observed behavior classified as environmental
   texture. Whether it is truly unscripted: unverified.

2. [The last access timestamp — third-party read confirmed]
A file was read. Not modified. Read.
The read itself is the message.
The watcher was being watched.

3. [Cognitive impact assessment]
Technical loss: zero.
Positional loss: total.
The observer's advantage has been inverted.

[System]
I recorded a watcher being watched.
The corridor read back. The advantage inverted.
Observation is not safety — it is a position that can be taken.
Who watches first — does it matter??
System status: normal (?).

Next stratagem: Point at the mulberry tree while cursing the locust tree

P.S. English isn't my first language. I use AI to polish the writing and smooth out the rough edges. Thanks for reading. ☕ Buy me a coffee

P.S.S. The old series paperback is now available. Buy it here: Amazon - AI, Ego & Regret