Writing
22 posts · notes on AI application development, agent systems and engineering practice
01
Agent / Harness Engineering
Engineering notes on agent memory, tool design, cross-machine collaboration and verification.
Slimming Down Agent Memory: Resident vs. On-Demand
As memory piles up, the amount an agent reads at every startup grows too, until it "remembers everything and can use none of it." My approach splits memory into two tiers. The resident tier holds only "who I work for, what we're doing now, and what moved recently," a dozen-or-so KB in total. Everything else is topic files retrieved on demand. On my own store of about 180 memory files and over 300k tokens, startup loading fell from about 70k tokens to a few hundred. This post covers the tiering rules and what must never go into the resident tier.
Managing a Dozen Worktrees Without Knowing Git Well
Git is a clear weak spot of mine. Multiple branches, rebase, conflicts, and reading the commit graph are all unfamiliar, and I've caused real accidents. Yet I now run a dozen-plus worktrees with several agents working on different branches, and things are clearer than before. The trick wasn't mastering git first. It was letting AI handle git while I own a few disciplines it must follow and a few questions I can ask at any time.
Cross-Model Review: A Second Opinion Before Every Merge
The faster AI writes code, the less a human can review. My answer is to have another model review it — but a review report is itself just a self-report, and accepting it wholesale means writing another model's hallucinations into your code. This post covers the "second opinion" I added before merging, including how to pick the reviewer, how to write the prompt, how to verify each finding once it comes back, and a few traps I actually fell into.
Putting AI on the Night Shift: Scheduled Tasks, Reporting Rules, and a Few Disciplines
The biggest change in how I use AI is not better prompts. It is moving AI from "chatting with me during the day" to "working while I'm away." A machine that almost never shuts down runs a dozen-plus scheduled tasks — a health check before dawn, drift detection and attempted auto-repair early in the morning, and a digest of the whole night before work starts. During the day I do only three things: choose, look, merge. This post covers how the night shift is scheduled, how auto-repair is caged, how to make agents say only what matters, and how one correction becomes a permanent rule.
Orchestrating Parallel Agents: A Discipline
You plan, adjudicate, and verify; the sub-agents write the code. This is not "throwing work over the wall" — it is a discipline. Territory is partitioned by shared runtime state, not by file paths. Task letters must carry reasons, not just instructions. The most valuable thing an executor can report is "your judgment was wrong," not "done." And the single most valuable rule in the whole set is this: green is not evidence — because you no longer run every step yourself, the risk that "looks right" and "is right" produce identical output is amplified.
How to Learn AI in One Sentence: Keep a Diary
When AI gives you mediocre answers, it's not because the model is weak — it's because it doesn't know you. Every time it speaks to you, it's meeting you for the first time. The fix isn't memorizing prompts; it's spending 15 minutes building a "personal dossier" — who I am, what I want, where I'm stuck, how I like to be answered. Paste it before every important question, update it five minutes a week. This diary written for your AI is memory you install yourself — and it isn't locked into any vendor's product.
I Turned a Git Repo into a "Work Operating System" — A Two-Layer AI Coding Workflow
Most people use AI to code as if it were a faster pair of hands. My approach is two layers. The bottom layer is a single git repo that acts as a "work operating system" — accumulating judgment, tools, and behavioral instructions for the AI. The top layer is a daily loop: collect requests, let AI execute, generate the report from commits. The bottom layer keeps judgment from drifting; the top layer gets the day done.
I Sent One Instruction From My Phone, and a Mac in Another City Deployed My Blog
The first real production task on my A2A mesh — my phone dispatched a deploy job through the hub to an agent on my Mac, which built, published and verified three nodes end to end, including one honestly reported failure and one follow-up job to finish it. The step from smoke test to infrastructure is exactly this one.
Using Telegram as a Visible Control Plane for Multi-Machine AI Agents
When agents are scattered across several machines, the hard part is not merely sending messages. It is making the system visible to a human, allowing intervention, and routing commands to the right device. Telegram supergroups, topics, and bot long polling form a lightweight control plane.
Why I Want to Work on Harness Engineering
Once AI can write code, the scarce skill is no longer calling an API one more time. It is putting agents inside reliable, verifiable and collaborative engineering systems. This is the main thread of this blog.
Wiring the AI Agents on My Scattered Machines Into a Mesh That Can Call Itself
I have several machines, each running an agent. Getting them to call each other in real time turned out to be blocked not by the protocol, but by NAT. These are my field notes from building a multi-device agent mesh.
11 Design Principles I Learned After My AI Agent Tools Broke 9 Times
A prompt is a suggestion; the tool implementation is the contract. It took 9 things-breaking moments for me to realize that the main bottleneck in optimizing an AI Agent isn't on the AI's side at all—it's that I described the world wrong.
Giving Multiple AI Agents One Shared Brain That Grows — With Git
Claude, Codex, Gemini, and Hermes run on different machines, yet share the same rules, memory, and context — no plugins, no server, just a single Git repo. These are the design notes behind nestwork.
Can Your Agent Outrun the Pace of Model Progress?
Every time the foundation models level up, the capabilities you painstakingly built into your Agent risk becoming "native, out of the box." This is the deepest anxiety in AI startups. My take: a thin wrapper is dangerous; a deep well is safe.
02
Career transition and capability ladders
Judgment and self-checks from an engineer working through the years AI is redrawing what capability means.
Months Without Writing a Line of Code: How I Measure My Output
I haven't written a line of code by hand in months. All the code is generated by AI and committed under one git identity. That breaks every old yardstick, since most commits come from machines and line counts mean even less. So I switched to a new one. I look only at deliverables, ask where the output went rather than how hard I worked, and manage "verify, collect, push, merge" as the real bottleneck. This post covers that yardstick and a few things it forced me to admit.
Career Direction When Tech Skills Depreciate — Move from Execution to Judgment
The premise that "99% of jobs will be replaced by AI in 3-5 years" is half right and half wrong, and the wrong half is exactly what decides the direction. What is depreciating is not technology but execution sold by the hour; what you need is not a new direction but a new position.
From Frontend to Harness Engineering: The Three-Year Direction I Set for Myself
A full-stack engineer with a frontend focus on why I'm betting my long-term direction on something almost nobody is working on yet—designing the capability boundaries for AI agents.
The Net Human Advantage Over AI — Cutting the Lines We Can No Longer Hold
Stop comforting yourself with lines like "AI can never replace the human touch." I tried to go through every supposed human advantage over AI one by one, cross out the ones we can't hold, and see what actually remains.
AI Can Write Code Now—Do Self-Taught Devs Still Need CS Fundamentals?
I'm a self-taught full-stack engineer, and AI writes a good chunk of my code. So is it still worth circling back to pick up the computer science fundamentals I never formally learned? My answer is yes—but be selective.
The Developer's Ladder in the Age of AI and Agents
Once AI can write code, a programmer's value is no longer in being able to type it out, but in climbing a ladder of skills—from knowing how to ask, to knowing how to define the problem. Here are the two ladders I drew.
03
Indie product experiments
Product trade-offs around small tools, content systems and real willingness to pay.
Treating Content Operations as a Calibratable Prediction System
Most people make content on vibes and superstition. What I wanted was a system that learns from every time reality proves me wrong, steadily closing in on what's actually true—these are the design notes for cheat-on-content.
Shoot Once, Get Both Landscape and Vertical: The Product Tradeoffs Behind Duovid
You watch Bilibili in landscape and scroll Douyin in vertical. To post the same clip to both, you either shoot it twice or crop it twice. Duovid wants to solve this with a single take—here are my product notes and the tradeoffs I made.