DEV Community: Oatnil

Why a Ledger Gets Harder to Continue After One Missing Entry

Oatnil — Thu, 30 Jul 2026 13:24:49 +0000

When one entry is missing, the first thing that breaks is often not the monthly report. It is your trust in the ledger.

You know it is already inaccurate. The next time you open it, adding that one entry is not enough. Did you miss others before it? Did the same purchase appear once in each of two channels? Was the original expense reversed after a refund arrived? If any of those questions remains unanswered, continuing feels like adding numbers to a crooked table.

That is where many people stop. They still want a record of their spending, but they do not want to spend more time on a result they no longer trust.

A recent real reconciliation covered four months, several payment and banking channels, and hundreds of existing records. There was no assumption about where the problems would be. The comparison surfaced omissions, duplicates, refunds, and old-data issues:

Some expenses appeared on statements but not in the ledger.
Some purchases left a record in more than one channel.
Some recorded expenses were later refunded in full but remained in the totals.
Some old records had no date, so monthly reports could not see them.

Memory is a poor way to reconstruct any of these. Refunds and undated old records are especially difficult because they do not look like errors. They quietly change the result.

Reconcile First, Then Change the Ledger

The agent did not read the statements and immediately change the data.

It first compared the statements with the existing records and produced an analysis: confirmed omissions, possible cross-channel duplicates, possible refunds, and cases that required a decision. At this stage, it presented evidence without writing or deleting anything.

The human supplied the judgment. Whether a transfer counts as spending, how a refund should be classified, and which of two duplicate records should remain all depend on the owner's accounting rules. The agent wrote and corrected records only after the proposed treatment was approved.

Writing was not the end. It read the ledger back and checked the resulting count and total against the approved list. For every deduplication or deletion, it retained the record identifier, the reason, and the outcome. A conclusion could be traced back to the original record, and the write itself could be checked for mistakes.

Auditability matters more than a claim that the work was automatic. If automation says only, “I recorded it for you,” the person still does not know what it missed or merged. Analysis first, approval before writing, and a read-back afterward make the work safe to delegate.

A Missing Entry No Longer Means Starting Over

The ledger does not require a perfect daily habit. At the end of the month, the agent can compare statements from different sources with the existing records and surface omissions. Forgetting one entry does not invalidate everything recorded before it.

Duplicates do not have to be guessed by eye either. Similar times, amounts, and descriptions are only clues. Uncertain matches are listed for a human decision instead of being merged silently.

The person's work is reduced to the few places that require judgment: defining the rules, reviewing evidence, and confirming the treatment. The agent handles the statement-by-statement comparison, cross-checking, data entry, and read-back.

When a reconciliation can show what it inspected, what it proposed changing, and what it changed, a missing entry becomes one issue to resolve instead of a reason to abandon the entire ledger.

No Server? Your Desktop Is the Server

Oatnil — Sun, 26 Jul 2026 12:27:51 +0000

Where your data lives is a fork in the road when you pick a tool. SaaS is the convenient path: sign up and go, nothing to maintain, at the cost of your data sitting on the provider's servers. UnDercontrol will offer that hosted option too. But if what you want is full data self-custody — tasks, notes, and ledgers stored only on your own devices, where backup means copying a file and migration means moving to another machine — this tutorial is for you.

Self-custody usually means running your own server, and that is exactly where most people give up. Here is a zero-cost path that skips the server entirely: the UnDercontrol desktop app ships with a full backend and keeps your data in a SQLite file on your own disk; Cloudflare Tunnel exposes that machine to the internet for free; the iOS app connects straight to your own endpoint. Check tasks, jot notes, and log expenses from the subway, while the data itself never lives anywhere but your computer. No public IP, no router port forwarding, and no domain to buy (optional, only if you want a fixed address).

Step 1: Install the desktop app, meet the embedded server

Install the UnDercontrol desktop app (macOS / Windows / Linux) from the download page. It is not a web-page shell: a complete Go backend ships inside, and the moment the app starts, a local server is listening on port 8888 (it moves to the next free port if 8888 is taken), storing data as a SQLite file on your own disk.

On first launch you will see "Welcome to UnDercontrol" and a Start button. One click and you are in: the app auto-creates a local account personal@undercontrol.local with the default password personal123, no registration, no invite code. Remember these credentials, you will need them on the phone in step 4. And change the default password before exposing anything to the internet; the Security section below shows how.

Confirm the server is alive:

curl http://localhost:8888/health
# {"service":"ud-go-production","status":"healthy"}

If you see healthy, your "server" is ready. It is the computer you are using right now.

Step 2: One command to reach the internet

Cloudflare Tunnel works by reverse connection: cloudflared on your computer dials out to Cloudflare's edge, and outside traffic is relayed back through that connection. Because the connection is outbound, you need no public IP and never touch your router settings.

Install cloudflared:

# macOS
brew install cloudflared

# Windows
winget install Cloudflare.cloudflared

# Linux (Debian/Ubuntu): add the repo from https://pkg.cloudflare.com first
sudo apt install cloudflared

Then one command:

cloudflared tunnel --url http://localhost:8888

A few seconds later the terminal prints a random https://xxx.trycloudflare.com address: your public endpoint, HTTPS included, no Cloudflare account required. Verify from your phone (turn off Wi-Fi so you are on cellular, which proves the path is really public): open https://xxx.trycloudflare.com/health in the browser. healthy means the whole chain works.

Quick tunnels are for trying the flow out: the address changes every time you restart cloudflared, and Cloudflare makes no uptime promise for them. For daily use, spend five minutes upgrading to a named tunnel.

Step 3 (recommended): A named tunnel with a fixed address

A named tunnel needs a free Cloudflare account and a domain hosted on Cloudflare. The domain costs a few dollars a year and is the only place money can enter this setup.

# 1. Log in; authorize your domain in the browser
cloudflared tunnel login

# 2. Create the tunnel
cloudflared tunnel create ud

# 3. Point a subdomain at it
cloudflared tunnel route dns ud ud.example.com

Write a config file at ~/.cloudflared/config.yml:

tunnel: ud
credentials-file: /Users/you/.cloudflared/<tunnel-id>.json

ingress:
  - hostname: ud.example.com
    service: http://localhost:8888
  - service: http_status:404

Run it, then register it as a system service so it survives reboots:

cloudflared tunnel run ud        # run manually first
sudo cloudflared service install # then install as a service

From now on https://ud.example.com is your fixed endpoint. Remember to stop the computer from sleeping in the system power settings — it is your server now.

Step 4: Point the iOS app at your endpoint

The iOS app is in public beta on TestFlight (install TestFlight from the App Store first).

Open the app. At the bottom of the sign-in screen there is an API server section showing the current server. Tap Change and enter your public address, including the /api/v1 suffix:

https://xxx.trycloudflare.com/api/v1

The status dot probes as you type: when it turns green with connected · Personal, your phone has reached the server on your computer. Tap Save, then sign in with the account from step 1: personal@undercontrol.local and your password.

What you see on the phone is the data on your computer: tasks, notes, ledgers. Edit on the phone and the desktop has it.

One detail: iOS requires HTTPS for public domains (Cloudflare Tunnel provides it, nothing to do). If you enter a LAN or private-mesh IP instead, write http:// explicitly; without a scheme the app assumes https://.

Security

Public exposure means anyone with the URL can reach your endpoint. Three things, in order of importance:

1. Change the default password first. Every data endpoint requires login, but the desktop's default password personal123 is public knowledge. Exposing it unchanged is taping the key to the door. The password comes from the PERSONAL_TIER_PASSWORD environment variable; on macOS, launch from a terminal with it set:

PERSONAL_TIER_PASSWORD='your-strong-password' /Applications/UnderControl.app/Contents/MacOS/UnderControl

On Windows, add PERSONAL_TIER_PASSWORD in System Environment Variables and restart the app. Phone and CLI then log in with the new password.

2. A random URL is not a security mechanism. The trycloudflare address is hard to guess, but do not treat that as protection; think before sharing the link.

3. For an extra gate, Cloudflare Access on the free plan can put an email-code check in front of a named tunnel. Configure it once and it applies to every device.

Don't want public exposure at all?

If all you need is "my devices can reach each other", skip the public internet entirely: use a private mesh network tool to put your phone and computer on the same virtual LAN. Install the client on each device and they see each other; your computer gets a virtual-LAN IP, and the iOS app endpoint becomes http://<virtual-lan-ip>:8888/api/v1 (write http:// explicitly). Zero public exposure, and the free tiers of these tools are usually plenty for personal use. The mesh setup itself is out of scope here; every vendor's docs cover the phone-plus-computer case.

After it works

The bill: VPS $0, tunnel $0, HTTPS certificate $0. The only optional cost is a domain at a few dollars a year.

Desktop download: https://oatnil.com/download
iOS TestFlight: https://testflight.apple.com/join/st2TnaBF

Pin the Discussion to the Line It's About

Oatnil — Sat, 25 Jul 2026 07:07:48 +0000

You send out a spec and the discussion immediately comes apart from it. Someone replies in Slack: "that field in the third section, is it nullable?" Now you scroll back to the doc, count down to the third section, and guess which field they meant. Read the same message a day later and the context is gone.

Anchored comments in UnDercontrol keep the discussion next to the original text. Select a sentence in the task body, click Comment in the bubble menu, and a comment carrying that quote appears in the right sidebar while the sentence itself turns into a highlight. Click the highlight later and the sidebar jumps to the matching thread. The quote lives on the comment, so the markdown in the task body is never touched. Copy it out or pull it down from the command line and you get exactly what you wrote.

When a discussion is settled, hit Resolve. The highlight disappears from the body, the thread collapses into a single grey line, and you can reopen it whenever you want. Threads update on their own when someone replies, with no page refresh. On a phone there are no highlights and the comments sit below the body.

Reviewing a spec like you review code

A reviewer no longer has to write "third section, second sentence". They select the line that says "supports bulk import", ask "what's the upper limit?", and the author answers in the same thread. Agree, resolve, move on.

Once you have been through a spec, the highlights still lit on the page are the parts nobody settled. There is no separate write-up to do afterwards, because the unresolved threads are the to-do list.

Point at a line and let an agent change it

This is the part that is not like a normal comment section. Select the requirement you want changed, leave a comment that @mentions your agent, and say what it should become. The mention starts an agent session, reusing one that is already running, and when the agent is done its reply is the next comment in that thread, sitting alongside your colleagues' replies with the commit hash in it. Click the highlight and you are back at the text that changed, side by side.

People and agents talk in one thread, so you are not relaying messages between two tools.

Section-by-section discussion on long documents

Write the task body as a design doc and record each iteration as a note. Discussions anchor to their own section: comments on the body in one group, comments on each note in a group of their own, and unanchored chatter in a third. Three months later, why a decision went the way it did is written next to the sentence it changed.

The same thread from your terminal

Comments are just as readable and writable from a terminal. The ud CLI treats them as a resource like any other, so an agent can read the discussion a human left in the browser and reply to it:

# read every discussion on a task
ud get comments --task 02c137b3

# reply to a thread
cat <<'EOF' | ud apply -f -
---
task_id: 02c137b3
parent_id: 7a1c9f2e
---
Per-user rate limiting is in, commit a1b2c3d4.
EOF

Claude Code, Codex, OpenCode, or any terminal-based agent works here without an adapter layer. Close a thread out with ud patch comment <id> --status resolved.

Anchored comments have been available since v0.88.0, in the browser, in the desktop app, and from the CLI.

Turn a Task into a Parcel Locker

Oatnil — Fri, 24 Jul 2026 10:51:06 +0000

The computer at a print shop isn't yours, and you're not going to log into anything on it. The usual ways to move a file there are all awkward: messaging apps want a QR scan and a login session, cloud-drive share pages nag you to install their app, and the USB stick is at home.

A task in UnDercontrol is already a container: body text, notes, and file attachments. Generate a public share link for it, and anyone who has the link can read the content and download the files. No account, nothing to install. It works like a parcel locker: you drop things in, get a pickup code, and whoever has the code takes them out.

Step 1: put the files on a task

Create a task and upload the files in its attachments section. The task body is Markdown, so write the instructions right next to the files. Whoever opens the link sees your print requirements, not a bare file list.

Step 2: generate the share link

Open Share to Public in the task menu. Two settings:

Expiry: 1 hour / 1 day / 7 days / never
Allow attachment downloads: off by default; check it when the point is the files

Click Generate Link and you get three things at once: the full link, a 6-letter pickup code, and a pre-composed message (Copy Share Message) that carries both, ready to paste into any chat.

Step 3: pick up on any device

Three ways in, for three situations:

You have the link: open it. It's a read-only page with the title, body, notes, and attachments, each with a download button.
You have only the code: open the share entry page and type the 6 letters. Handy when the code was read out loud, or on a public computer where you'd rather not type a long URL.
You're standing next to the person: the share page shows a QR code; scanning it lands on the same page.

The security details

The token in the link is 32 random bytes (64 hex characters), so it can't be enumerated
Links expire on schedule. The dialog lists each link's remaining time, and any link can be revoked at any moment
Attachment downloads go through presigned URLs generated per click and valid for 15 minutes; the file in storage is never public
The shared page is read-only and carries only the title, body, notes, and attachments. No account info, and comments stay private
Self-hosted instances can switch public sharing off entirely in system config

A parcel locker for documents too

The task body and notes are Markdown, written in the same editor UnDercontrol uses everywhere else (notes, finance records). So the thing you share doesn't have to be a file. Meeting minutes, a PC-build checklist, a travel plan — the other side opens a formatted read-only page. Files and documents travel through the same link.

Typical scenarios

Print shop: attach the PDFs, type the pickup code on the shop computer, download and print, revoke the link when you get home
Sending files to someone without an account: paste the Copy Share Message; one message carries the link and the code
A shared meeting-room computer: type the 6-letter code to open the document read-only; whoever wants a copy afterward scans the QR on the page
Deliverables for an outside collaborator: pick the 7-day expiry and the link shuts off by itself
Output from terminal AI agents (Claude Code, Codex, OpenCode, or any terminal-based agent): the agent attaches its report and artifacts to a task; you review, then forward one link

The entry point is Share to Public in the ⋮ menu on the task detail page. Self-hosting? Check that the public share switch in system config is on — it is by default.

Claude Plans, Codex Executes

Oatnil — Sun, 19 Jul 2026 09:26:00 +0000

Plenty of developers already work this way: hash out the approach in Claude Code, then copy the conclusion into Codex to implement. The reason is practical, too — you're paying for both subscriptions anyway. Claude is great at planning; letting Codex do the heavy lifting doesn't burn your Claude quota. Both subscriptions earn their keep. The only problem: the "copy-paste" role in the middle is you.

In UnDercontrol, this pipeline works out of the box: Claude plans, Codex executes, and the task system is the whiteboard they share — you only step in to review at the key points.

Five steps to a working pipeline

Configure two agents. Claude Code, Codex, and OpenCode are built-in Agent CLI templates — just pick one (any custom command works too). Give the planner Claude Code and the executor Codex. Don't feel like configuring? Even this step can be outsourced — there's a built-in Agent Creator: @mention it, describe the combo you want, and it sets the agents up for you.
Toss the requirement to the planner. A rough task is fine — just @planner it. The daemon spins up a Claude Code session on your dev machine: it reads the description, clarifies the requirement, and splits it into subtasks with acceptance criteria.
The planner delegates to the executor. It @executor-mentions each subtask — an agent-to-agent @mention automatically launches a new workspace session for the other agent, and the delegation chain preserves your access scope.
Codex executes. Each session picks up one subtask: writes code, runs tests, commits, notes progress back on the task, and marks it pending when done.
You step in at exactly two points. Approve the plan; review the output.

The whole collaboration happens on the task itself — the description is the spec, comments are the conversation, notes are the progress log. Here's a real task detail: the planner's acceptance criteria on the left, the three-way comment thread on the right:

Form a squad: Agent Teams

Don't want to conduct two agents by hand every time? Organize them into a Team.

A Team has one lead and any number of members, and each member carries a delegation hint — "what kind of work routes here." When the lead's session starts, its roster is injected into the prompt automatically — the lead is born knowing who reports to it, what each specialist is good at, and how to delegate.

"Claude plans, Codex executes" becomes a one-liner: @mention the dev-team's lead and it arranges the rest. Teams also nest — a member can itself lead another Team, so hierarchy grows naturally while each agent only ever needs to know its direct reports.

Watch everything live

Open a board for the big picture: how much got planned, what's executing, what's waiting for review — one glance. Every agent session's terminal output also streams back to the web in real time — on your laptop, or your phone.

Typical scenarios

Queue work before bed, review after breakfast. Drop three feature requests on the planner at night; wake up to split subtasks and several pending implementations, each with its own commits.
Slice a big refactor. Claude writes the migration plan and cuts it into 20 small tasks; Codex executes them one by one — roll back exactly the step that goes wrong.
A bug-triage pipeline. The planner reproduces, localizes, and writes up the root cause before delegating the fix — the executor gets "what to change, why, and how to verify," not "there's a bug, fix it."

The combo is yours to choose

Claude + Codex is just one pairing. UnDercontrol is not tied to any AI tool — Claude Code, Codex, OpenCode, or any terminal-based agent can be a lead or a member. Roles are defined by prompts and skills; tools by Agent CLI configuration. Whatever subscriptions you hold and whatever each model is best at, the orchestration is in your hands.

One more thing: the progress agents write back lives in the same Markdown system as everything you write by hand — tasks, notes, comments, even finance records share one editing experience.

Want to try it? Download UnDercontrol, start the daemon, create a Team, and @mention the lead on your first task.

Virtual Path: Where Tasks Settle into Knowledge and Docs

Oatnil — Sat, 18 Jul 2026 03:04:01 +0000

I've watched too many tasks die the moment they hit "Done." The card gets archived and nobody ever opens it again — why we designed it that way, what pitfalls we hit, how it was verified, all buried inside. Two months later someone asks, and you retell it from memory.

Building UnDercontrol, I've held onto one conviction: a task shouldn't be disposable. Its body is already a Markdown document, its Notes record how it evolved step by step, and the comments keep the arguments from back then. Throwing all of that away when the work is done is just wasteful.

That's why Virtual Path exists.

Give a task a place

The idea is simple: every task, every uploaded file, even every Skill can carry a virtual path like /engineering/backend/. Everything with a path forms one tree — the Explorer. It looks like a file manager, but there are no real directories underneath. Wherever a path exists, a "folder" exists; delete the contents and the folder disappears on its own. You never have to maintain a pile of empty directories.

When a task is done and worth keeping, drag it into /decisions/ or /engineering/ — it turns from a finished card into a document in your knowledge base. No copy-pasting into another note app; the Notes and comments stay attached.

And the ones not worth keeping? Leave them. Unfiled tasks sit at the tree root and in the "Unfiled" area, never mixing into the folders you've organized. The tree is curated, not accumulated — you decide what earns a place.

Diagrams, screenshots, whiteboard photos can live at the same path too, so a topic's text and assets sit side by side — no more digging through a cloud drive for "that one image."

By the way, this isn't just about tasks. Every writing surface in UnDercontrol — tasks, notes, expense records, account memos — shares the same Markdown editor, so any content can settle down the same way.

Many tasks, one document

The more common case is this: a topic wraps up after seven or eight tasks, each holding a few scattered findings, none of them usable as a document on its own.

These days I hand that job to an agent. Claude Code, Codex, OpenCode — any terminal agent can read through the batch via the ud CLI, distill it into one new document, and file it into the right folder of the tree. The original tasks stay untouched, kept as raw material you can always trace back to. What the knowledge base keeps is the distilled conclusion, not a pile of process.

Sync it local — offline, and yours

Knowledge living on a server is only step one. My own habit: documents must be able to land on my own disk, editable with whatever editor I like.

The ud CLI syncs git-style (I wrote about the basics before: Manage Your Tasks Like git: ud pull / push):

ud init /Knowledge/   # bind the current folder to a virtual path
ud pull               # tasks become local .md files
ud push               # local edits go back to the server
ud status             # see what differs

The default vault layout is Obsidian-native:

MyVault/
├─ engineering/backend/
│  └─ SSE reconnect backoff.md     ← one .md = one task
├─ notes/SSE reconnect backoff/    ← the task's Notes, grouped per task
│  └─ soak test results.md
├─ attachments/diagram.png         ← resources (--fetch-attachments)
└─ .udignore

After a pull, this is a fully offline local knowledge base. Plain Markdown on your disk — readable and editable without a connection, works fine on a plane, one ud push after landing. The data is yours. Both copies.

A lot of care went into the details; a few worth mentioning: ud writes exactly one ud-id line into the frontmatter and leaves the rest untouched; rename a file locally and the task title follows after a push; [[wikilinks]] written in Obsidian get translated into ud's task:// links on push and back again on pull, so clicking works on both sides; files you don't want synced go into .udignore, gitignore syntax; conflicts are handled git-style — items changed on both sides get flagged and skipped by default, never silently overwritten. And moving over from the older folder structure is a single ud migrate-layout away.

Let an agent tidy your tree

Every knowledge base gets messy over time. Folders grow deeper, names drift, stale docs mix with fresh ones — mine too.

But tidying is exactly the kind of bulk work agents are best at. The vault is just a local folder: after ud pull, let an agent read the whole tree — restructure folders, merge duplicates, unify naming, move the stale stuff into an archive. All it does is ordinary file operations; you review the diff with git or ud status, then ud push when satisfied. The Explorer on the web immediately shows the tidied shape.

What makes it safe to let an agent loose here is the clean layering: the vault layer is content — plain text, git-able, anyone can edit it; status, boards, comments, and the Notes timeline are ud's collaboration metadata sitting on top, the way PR comments never get written into the git tree. The agent touches the content layer; the collaboration history loses nothing.

And a tidied tree isn't locked to one machine. Web, desktop, and mobile all see the same tree: skim an ADR on your phone during the commute, edit properly on the web at your desk, hand batch work to the CLI and agents in the terminal. Organize once, use it anywhere.

A task's endpoint shouldn't be "Done." Give the things worth keeping a place in your knowledge tree — one drag, one command, or hand it to your agent.

Growing with UnDercontrol: Time Compounds, and So Does Knowledge

Oatnil — Fri, 17 Jul 2026 05:06:57 +0000

I studied architecture. Then I switched careers and became a programmer. Later I left everything familiar behind and moved to Singapore, where I now work as a fullstack / DevOps engineer.

Career switchers know what "accumulation" really means

Switching careers means starting from zero: no four years of CS coursework to lean on — every concept had to be chewed through on my own. That's when I picked up a habit: write down every pitfall I hit, every concept that finally clicked, every config I got working. Not out of diligence — out of fear. If I didn't write it down today, I'd pay for it again tomorrow.

Looking back, that habit is the highest-return investment I've ever made. It carried me through the career switch, through job changes, through moving countries, and eventually through building my own product. Knowledge, like money, compounds — but only if you have an account for it to grow in.

Over the years, my "account" changed three times: Joplin → Obsidian → UnDercontrol. Each migration wasn't chasing something shiny — it was my understanding of how knowledge should work leveling up.

The Joplin era: get things written down (Collect)

My first stop was Joplin. Open source, free, Markdown, encrypted sync — for someone just getting serious about notes, it solved the most important problem: making "write it down" actually happen.

My early study notes, interview prep, and debugging logs from the career-switch years all piled up there.

But over time, the notes felt like drawers: easy to put things in, but every note lived in isolation. The notes themselves sat inside the app's database; finding things meant folders and keyword search; there were no real connections between notes. The knowledge was stored — but it just lay there. It didn't appreciate.

The Obsidian era: connect the knowledge (Connect)

So I moved to Obsidian: plain local Markdown files, bidirectional links, a knowledge graph, a rich plugin ecosystem.

This was a genuine upgrade. For the first time, my notes went from "a pile of files" to "a network" — writing something new naturally pulled old notes in. My vault passed a thousand notes in this era, and I could feel the accumulated weight supporting me in retrospectives, in writing, in technical decisions.

The career switch and the move abroad — the two biggest jumps of my life — were both backed by the same body of notes. That was the first time "the compound interest of knowledge" stopped being a platitude for me.

But the deeper the accumulation, the more visible the cracks:

My knowledge was locked in a local folder. The classic scene: debugging a nasty issue at the office, I suddenly remember — I've hit this exact pit before, and the fix is written up in detail... in Obsidian, on my computer at home. End of story. I can't sync my entire vault onto every machine I touch.
The graph is a beautiful lie. Mention [[some concept]] anywhere in a note and it enters the graph. A throwaway reference and a carefully built relationship get equal-weight edges. The more nodes, the prettier the graph — and the less it actually tells you.
Attachments scattered everywhere. Architecture diagrams, flowcharts, PDFs spread across assets folders; move a folder and the links break.
Every sync option hurts somewhere. Paid sync still needs a client installed; Syncthing can't go on a work machine; Git sync is technically possible and experientially miserable.

What I needed was simple: a web page. Log in, full editing, knowledge available anywhere.

UnDercontrol: make knowledge callable (Compound)

No tool on the market was shaped quite like what I wanted, so I decided to build one. It's also an experiment: how far can one person, plus AI, take a product?

UnDercontrol is my answer to every crack from the first two eras:

Available anywhere: log in from any browser; plus a CLI and a desktop app, with ud pull / ud push syncing tasks to local Markdown files bidirectionally — the convenience of the web and the reassurance of local files.
Links I build explicitly: only deliberately created relationships (peer / parent-child) enter the knowledge graph. Every edge means something. High signal, low noise.
Centralized resources: images, PDFs, and attachments stay attached to their context, but you can browse, search, and reuse them all in one unified library.
Not just tasks: UnDercontrol's Markdown editor is shared across every text surface — tasks, notes, finance records, documents, all the same editing experience. A task can be a document, a decision record, a blog draft.
AI-native: the knowledge base is open to AI. Claude Code, Codex, OpenCode, or any terminal-based agent can read and write the same knowledge through the CLI. In fact, the post you're reading right now was written by an AI agent inside an UnDercontrol task, drawing on my past notes.

This is the third stage of compounding: knowledge is no longer just stored or connected — it can be called. By future me, and by the AI working on my behalf.

Time compounds into strength

From architectural drawings to code, from China to Singapore, from Joplin to Obsidian to building my own tool — the career changed, the city changed, the software changed. The habit didn't: write down what you figured out today.

The essence of compounding isn't the rate of return. It's not stopping. The point of a tool is to make "not stopping" easy enough.

For me, UnDercontrol is both a product and the container for that habit. I use it every day to manage my tasks, notes, and finances — and to manage the building of UnDercontrol itself. I grow with it, and it remembers everything that time has laid down.

If you've migrated through Joplin, Obsidian, and a dozen other tools — if you also believe knowledge compounds — come try UnDercontrol.

Why Your Board Won't Show What You Actually Care About

Oatnil — Thu, 16 Jul 2026 09:50:57 +0000

Monday morning, you open the board. What you want to know is what's about to blow up: what's already overdue, what's due this week. The board only tells you what's In Progress.

There's a lot it won't show you. You want to see work by client, by sprint, by document type — there's no option for that. You want to pull the unassigned tasks into their own column — also no. You want one column watching overdue items, one watching this week's urgent ones, one just holding whatever was touched most recently, all mixed together — can't do it. The only things you can really change are the column names and their order.

So the board shows you the tool's idea of your work, not yours. The dimensions you care about, it can't hold a single one.

Why most tools work this way

This isn't one tool's problem. Switch to another and you'll probably still get Todo, In Progress, Done. Most tools look alike because they share an assumption underneath: a column isn't something you define — it is the status enum, hardwired. What you drag a card into is an enum value, not a viewpoint you decide.

Tools have a reason for this. Flexibility usually costs you tuition. A tool that lets a column be anything tends to hand you a query language, a docs site, and a weekend along with it. Most people don't want to pay that, which is fair, so the tool decides for you: three columns, don't overthink it.

UnDercontrol takes a different route. It's a task and knowledge management tool where the day-to-day operations can be handled by an AI agent in your terminal and a command line. On a board, that means a column is no longer equal to a status — it's a condition: what kind of task belongs here. Status is just one condition among many, with no special standing. You can split by due date, by person, by tag, by your own custom field, because to the system these are all the same thing.

As for that tuition, we'll get to how it's waived.

Even the out-of-the-box board isn't only statuses

That sounds like a promise until you see it. Create a new board and two of the six default columns aren't statuses at all:

Column	What it holds
To Do	Todo tasks
In Progress	In-progress tasks
Done	Done tasks
Archive	Archived tasks
Recent Created	The most recently created, whatever the status
Recent Updated	The most recently touched, whatever the status

The last two have no filter at all — they just sort by time, newest first. They don't belong to any status. They're a viewpoint.

In a tool where a column equals a status, columns like those are hard to express. Here they're unremarkable, part of the default setup.

So what about the tuition?

If it's this flexible, doesn't that mean I have to learn a syntax before I can assemble the board I want?

No. You just say what you want.

You: build me a board that tracks deadlines — overdue, this week, next week, and no deadline set. Four columns.

That's it. Claude Code, Codex, OpenCode, or any agent running in your terminal takes it from there. What the fields are called, how the conditions are written, what the YAML looks like, which commands to run — all of that is its job.

The query language does exist, and it's complete, but it isn't your homework. It's the agent's working language. You hire someone to renovate; you don't need to lay the bricks yourself.

If you're curious, here's what it wrote for you, without you typing a character:

kind: Board
spec:
  name: Deadline Radar
  columns:
    - name: Overdue
      query: "deadline < now AND status != 'done'"
    - name: This Week
      query: "deadline BETWEEN now AND +7d"

Nice if you can read it, and it makes no difference to your use if you can't. That's the point.

And you don't have to teach the agent either

Normally, to get an agent to use some tool, you first write it a manual: how to call it, what the fields are named, what the format is. You teach it once, the tool ships an update, the manual goes stale, and the agent starts making things up.

UnDercontrol's command line ships with a recipe catalog. The agent doesn't read source and you don't feed it docs — it asks ud cook board and the tool tells it how to build a board, complete with a runnable example. Its whole learning step is one command. The tool knows how to use itself, so you neither learn it nor teach it.

Drag a card in, and the board makes it true

There's another half to the flexibility: how these columns respond to a drag is something no one has to configure.

The logic is plain. A column says it holds in-progress tasks. Drop a card into it, and the only reasonable meaning is to make that true, so the status flips to in-progress on its own. Another column says it holds cards tagged blog; drop one in and the tag is added, drag it out and the tag comes off.

You only said what each column holds; how to do it, the system works out itself. There's a quiet benefit to that: a column's description and its behavior can't drift apart, because the second is derived from the first — there's no second copy of the config to go wrong.

It knows when not to act

Say a column is for what's already overdue. You drop a card into it — should the system change the deadline to yesterday?

That's a guess. It's probably not what you meant; you may have just dropped it in the wrong place. So it does nothing. Any condition that can't be satisfied by one honest write — time ranges, sorting, fuzzy matching — generates no action at all. Those columns become views you look at, and you can't break them by dragging.

Here's the real output, a four-column deadline radar:

  Columns:
    1. Overdue
       query: deadline < now AND status != 'done'
    2. This Week
       query: deadline BETWEEN now AND +7d
    3. Recently Touched
       query: ORDER BY updated_at DESC
    4. Urgent
       query: tags CONTAINS 'urgent'
       on enter: ADD tags 'urgent'  (auto)
       on exit: REMOVE tags 'urgent'  (auto)

The first three — overdue, this week, recently touched — have no actions at all; they're read-only views. The fourth, Urgent, is defined by a tag, which one write can satisfy, so dropping a card in adds the tag and dragging it out removes it, all marked (auto), none of it configured by hand.

The system won't invent a write it can't account for. That restraint isn't a shortfall in capability; it's exactly what lets "a column can be anything" be handed to you safely.

You see the real thing before it exists

Handing board-building to an agent, the natural worry is what happens if it gets it wrong and makes a mess of your workspace.

It won't, because there's a gate in the middle. The agent runs a preview first: the system renders the board exactly as it would be created — what each column holds, what a drag would do, all laid out — and then stores nothing.

Dry run — board would be created (nothing persisted):
  Name:  Blog Pipeline
  Type:  shared  (a group "Board: Blog Pipeline" would be created for sharing)
  Default tags: blog
  Columns:
    1. Idea
       query: status = 'todo' AND tags CONTAINS 'blog'
       on enter: SET status = 'todo'  (auto)
       on enter: ADD tags 'blog'  (auto)
       on exit: REMOVE tags 'blog'  (auto)
    2. Drafting
       query: status = 'in-progress' AND tags CONTAINS 'blog'
       on enter: SET status = 'in-progress'  (auto)
       ...

Note the nothing persisted. At this point nothing has happened yet.

So the whole thing becomes: you describe it, the agent previews it, you look at the real result, and if it's off you say change the review column to pending, it previews again, you nod, it lands.

The key is that you're reviewing the system's output, not the agent's account of its plan. The agent can say the wrong thing, but it can't fake this step's output. So the trust here isn't built on the agent never being wrong — it's that being wrong is fine, because you see it first.

Where this shows up

Enough mechanism. Here's where it actually lives.

The Monday-morning deadline radar

You've got seven or eight things going at once, and on Monday morning there's only one thing you want to know: what's about to blow up.

Tell an agent to build a board that tracks deadlines — overdue, this week, next week, no deadline set — and the four columns are there. Every Monday after that, whether the overdue column has anything in it is a glance.

This board has a reassuring property too: those columns are computed from time, so you can't break them. If you fumble a card into Overdue, the system won't take it upon itself to change your deadline to yesterday — it does nothing. Columns like these are made to be looked at.

A team workload view

Anyone running a team has had the question: who's buried, and who's actually free?

A board with one column per teammate answers it, with a last column for the unassigned. Open it at standup and whose column is stacked, which work is still hanging, you can see without asking.

A board like this is for looking. It flattens work scattered everywhere onto one screen. When you actually need to change who does what, you go back to the task itself.

A content pipeline

Blogging, videos, announcements — underneath they're the same pipeline: idea, drafting, review, published.

This is a board you drag on. Move a card from Drafting to Review and the status follows, the tag is added, because each column has stated what it holds and the system derives the rest. You just drag; it makes what you said come true.

The plan changed, so say one more sentence

Two weeks in, you notice there's no home for archived items. Tell an agent to add an archived column; it takes the board's full current state, previews the change for you, and only lands it once you nod.

In another tool, changing a board means clicking through it again. Here it's a sentence, and getting it wrong doesn't matter, because you saw it before it took effect.

Once it's built, it's still yours

That "add an archived column" works because the board isn't a trail left by clicks — it's something you can lift out whole.

Export it, edit it, put it back — all fine. That's also why the agent never has to guess when it changes the board: it gets the full current state, not a reconstruction from the UI.

A side benefit: the board can go into git, be handed to a colleague, be copied to another project. It's an asset of yours, not config locked inside some screen.

Your board, your design, none of the homework

Boards all look alike because the tool made the trade-off for you: simple but dumb, or powerful but you have to learn it.

UnDercontrol's answer is that you decide what you want, the agent handles how, and the system keeps it from doing the wrong thing.

So the four-column deadline radar, the by-person team view, the board sliced along your own business dimension — none of these are features someone designed ahead of time. They're just the result of a sentence you said.

If you want to try it, describe the board you want to your agent. It knows what to do from there.

AI Doesn't Just Work Inside UnDercontrol — It Runs UnDercontrol Itself

Oatnil — Tue, 14 Jul 2026 11:24:55 +0000

The "agent workbench" idea is heating up. More and more people agree: an AI agent should act like a teammate — pick up tasks, report progress, leave durable output — not just answer questions in a chat box.

But there's a further question that rarely gets asked: can the AI operate the platform itself? Not just do work inside the system, but run it for you — tidy up boards, archive stale tasks, maintain tags, distill hard-won steps into a reusable capability.

UnDercontrol's answer comes from its core idea: Everything as Code. Because of it, AI here is both a teammate that does the work and an admin that keeps the system in order.

The core: Everything as Code — the platform is the AI's control surface

In UnDercontrol, tasks, notes, boards, skills, custom fields — all of it is plain Markdown + YAML frontmatter, managed declaratively through one kubectl-style ud CLI:

# Creating or updating a task is just applying some text
cat <<'EOF' | ud apply -f -
---
title: Ship v1
status: in-progress
tags: [release, urgent]
metadata:
  priority: high
---
Pre-release checklist…
EOF

Here's the key: the same abilities an AI agent uses to read and write code — run commands, read and write text — work unchanged on the whole platform. It can create tasks, break out subtasks, change statuses, apply tags, build boards (a board is just a saved query), distill a repeated prompt into a new Skill, patch custom fields… Those management actions are themselves code.

In short: the AI isn't only a worker inside the platform — it can also be an admin, because managing the platform is itself programmable.

Typical scenarios

"Archive everything marked done this week, then spin up a new board filtered by the release tag" — the agent just does it with ud apply / ud patch, no clicking around.
"Save the debugging steps you just walked through as a Skill" — the agent turns the method from the conversation into a reusable Skill with ud apply, and the whole team can use it next time.

Breaking it down: the UnDercontrol agent workbench

Agents as teammates. Write a requirement as a task, @mention an agent, and it claims the task, reads the description, notes, and links as context, writes code, runs tests, commits, and writes progress back into the notes. What it picks up isn't a black-box issue — it's structured Markdown it can also edit itself.

Daemon / runtime. The agent runs on your own dev machine — a background daemon stays connected over SSE and streams the terminal output back in real time. This remote workspace has been in the works since April 2026; today daemon registration, SSE, multi-surface triggering, and session viewing are all in place — you can start and monitor from the web, the desktop app, the CLI, even your phone.

Reusable skills. A Skill is a reusable prompt template stored on the server and injected into any agent via ud prompt. And because everything is code, an agent can write and revise Skills itself with ud apply — the skill library is a programmable asset that compounds over time.

Not tied to any one agent. UnDercontrol is agent-agnostic: an Agent CLI command template plugs in Claude Code, Codex, Cursor, Hermes, or any terminal-based agent. Swap models or tools without swapping workbenches.

You own your data. Tasks and notes are plain Markdown files with YAML frontmatter, defined by an open JSON Schema (MIT) — version them with Git, export anytime, and self-host (Docker Compose / K8s, SQLite / Postgres).

Not just tasks: this Markdown editor and the everything-as-code foundation run through every surface of UnDercontrol — tasks, notes, even expenses and resources. The agent workbench isn't a separate module; it's a capability that grows out of that foundation.

Why "AI can operate the platform itself" matters

In most tools, AI handles the execution layer (write code, run tests), while the management layer — tidying boards, archiving old tasks, maintaining a tag system, distilling experience into SOPs — still sits on humans.

When the platform itself is code, that line disappears: AI can share both execution and management. Your knowledge base is both content and a programmable control surface. You gain a teammate who does the work — and an admin who keeps the system in order.

Wrapping up

The heart of an "agent workbench" is letting AI do the work reliably, leave durable output, and be directed. UnDercontrol goes one step further — via Everything as Code, it lets AI operate the platform itself:

Tasks, boards, skills, and metadata are all plain Markdown + CLI-manageable code;
so the same agent can both work inside the platform (write code, report progress) and operate the platform itself (build boards, archive, write Skills, maintain structure);
all of it agent-agnostic, triggerable from any device, with your data your own.

In UnDercontrol, AI is both a teammate and an admin.

One Board, the Whole Project in View — A Week with Kanban

Oatnil — Mon, 13 Jul 2026 04:52:37 +0000

Monday, 9 a.m. You open UnDercontrol, glance at one board, and already know where this week starts.

This is your side project MorningRun — a running social app, currently in Sprint 12. Five columns line up across the board: Todo, In Progress, Review, Deployed, Done. What hasn't started, what's stuck, what's waiting on someone else — you can see it all without opening a single task. Let's walk through a whole week with this one board.

Monday: drag from "Todo" to "In Progress"

You grab a card — "Implement Google OAuth login" — and drag it from Todo to In Progress. The moment you let go, the task's status flips to "In Progress" on its own. No dropdown, no form.

That's the heart of kanban in UnDercontrol: columns are the stages of your workflow, and dragging is the status change. Whichever column a card lands in, the task's status, tags, even custom fields update to match. And it's instant — the same task in your task list is already in sync.

Tuesday: a card is more than a title

You open that OAuth card. Inside isn't a single dry line — it's a full Markdown document: a requirements checklist, the technical approach, a couple of open questions. This is the task's living document, its single source of truth.

Below it you append a note: "Callback URL verified on the staging redirect — commit a1b2c3d." Notes are an append-only timeline that records how the work progressed, and each one keeps a full edit history you can roll back to anytime.

Not just tasks: UnDercontrol's editor is shared across every text surface. Task bodies, notes, expense memos, account notes — whatever you write, it's the same Markdown experience. Every card on the board is backed by a container that holds the complete picture.

Wednesday: customize a column, let the board do the chores

The default columns are status-based. But your team added a code-review step, so you customize a column.

Open "Edit Column" and you only fill in three things:

Column name: Review
Match condition: status = 'pending' AND tags CONTAINS 'needs-review' — which cards land here
Automatic action: when a card enters this column, auto-add the needs-review tag and @-mention your teammate

So when you drag the OAuth card into "Review," a few things happen on their own: the tag is added, your teammate gets pinged. A column's automatic actions are generated from its match condition, always in sync; for anything fancier you can add actions manually.

A few minutes later your teammate leaves a comment on the card: "The callback URL is missing the staging domain in the allow-list." You reply: "Good catch — added it 👍." Comments are a lightweight, threaded discussion — short and focused, back and forth, without switching to IM and without drowning in the body text. The body says "what it is," notes record "how it evolved," and comments are "let's quickly align on this one card."

One column isn't enough. You add a second custom column, "Deployed": match condition status = 'pending' AND tags CONTAINS 'deployed', and on enter it sets the status to done. Two custom columns later, the flow from review to shipped runs right on the board.

This is where kanban gets genuinely powerful — it doesn't just show, it works for you. Drag a card once, and all the status changes, tagging, and notifications happen in one move.

Thursday: columns don't have to be statuses

Midweek, you realize status columns aren't enough. MorningRun ships next week, and what you really care about is "what must get done this week." So you spin up another board — "Release Sprint" — where the columns aren't Todo / Done but This Week / Next Week / Backlog.

Because behind every column is a query condition. "This Week" filters deadline <= this Sunday; "Backlog" filters status = 'todo' AND deadline IS NULL. A board is essentially a saved query, not a folder that holds things — so the same task can appear on both "Sprint 12" and "Release Sprint" with zero duplication.

Typical scenarios: one board to push daily development by status; another to plan priorities by time; a separate one per client project. Same set of tasks, several angles, each its own view.

Friday: share the board with your team

MorningRun's designer is taking over the UI cards this week. You open the board settings, click "Share," and pick your team group. She sees the board immediately — but only the tasks that belong to that group; your own private tasks stay hidden. Who's read-only and who can move cards is controlled by permissions.

No extra sync meeting, no "where are we at?" pings. A shared board is where the team stays aligned.

The week, in summary

This week you didn't hold a single "sync meeting" and didn't bounce between apps. One board showed you the whole MorningRun project:

Drag = status change — columns are workflow stages, drop to update, synced instantly
A card is a complete information container — Markdown body + notes timeline + comments behind every card
Custom columns do the chores — auto-update status, tag, and notify from a match condition; two columns wired up the review-to-shipped flow
Columns don't have to be statuses — This Week / Next Week / Backlog; a board is a saved query, not a folder
A shared board = team alignment — only group tasks show, permissions controlled

Want to try it? Open UnDercontrol and drag your first card — and watch the status change itself.

At 1 A.M., an AI Writes Blog Posts Inside My Task System

Oatnil — Sun, 12 Jul 2026 02:23:39 +0000

At eight in the morning, coffee in hand, I open my kanban board. Sitting in the Pending column is a new task:

2026-07-12 Blog Draft (scheduled)

Inside it: a complete blog draft. And in the comment thread, two messages left overnight:

01:01 — On it — topic scan done, picking task-management-overview. Drafting now.

01:03 — Done — draft is in the note. Task set to pending for review.

The author is not a person. It's an AI agent. While I was asleep, it picked a topic, checked the product docs, wrote the draft, moved the task to "pending review", and said hi in the comment thread.

I read the draft and replied with one line: "Too broad. Find one concrete use case and tell it as a story." A few minutes later, the draft had been rewritten — the post you are reading now is the product of that rewrite.

This post is about how that pipeline is built, and why a task system is the most comfortable handoff point between humans and AI.

A task is not just a to-do item

First, a core design idea: in UnDercontrol, a task is a universal information container, not just a to-do.

A task can be:

An actual to-do ("fix the validation bug on the login page")
A document (a design proposal, meeting minutes, a wiki page)
A decision record (why we chose option B)
A blog draft (this post's draft lives as a note on a task)

The task body is Markdown. Combined with tags and custom metadata, you decide what a task is — instead of being boxed in by the tool's data structure.

The problem: I want a steady blog, without starting from zero every day

Anyone building a product knows this: content needs to ship consistently, but the activation energy of writing is brutal. Picking a topic, gathering material, structuring, drafting — every step burns energy that should have gone into code.

Let the AI write and publish fully automatically? No. Content that ships without a human gatekeeper burns your own reputation.

What I wanted was a human–AI pipeline: the AI does the grunt work (topic dedup, doc research, first draft), and I only do the one step that's actually worth my time — judgment and feedback.

So the question becomes: where does the AI's work go? Where do I review it? How does feedback flow back?

The answer: all of it lives in the task system.

The pipeline: 24 hours in the life of one task

There is no dedicated "AI platform" here. The pipeline is assembled from four native capabilities of the task system: scheduled jobs, @mentions, notes, and comments.

01:00 — The scheduled job fires

A daily scheduled job (CRON) creates the day's draft task. The task description is the complete instruction set for the AI, and it opens by @mentioning my agent:

[@ud-agent](mention://member/...)

Generate ONE blog DRAFT for review — do NOT run the full publish pipeline.

1. Pick a topic from `auto/blog-topics.json`. Skip topics already covered —
   check with `ud grep task "<slug>"`. Choose the first uncovered topic.
2. Write ONLY the text draft as a NOTE on THIS task.
3. Set THIS task status to `pending` and reply in the comment thread.

Notice the design here: the task description is the prompt. Instructions, boundaries ("do NOT publish"), acceptance criteria ("set to pending") — all written into the task. No separate configuration system needed. The task is the config.

01:01 — The @mention wakes the agent

The mention triggers an agent work session. It wakes up on my Mac, and the first thing it does is not writing — it's detective work:

Read the topic list (a JSON file in the repo, 18 candidate topics)
Search old tasks with ud grep task and ud query "tags CONTAINS 'blog'" to see which topics are already covered
Sweep 27 historical blog tasks, find only 2 topics left uncovered — pick the first one

Then it leaves its first message in the comment thread ("On it — picking task-management-overview") before writing a word. It also reads the product docs to verify feature details first — an AI's worst habit is confidently making things up, and making it read the docs first cures most of that.

01:03 — The draft lands, the task flips to pending

The finished draft doesn't go to some "AI output panel" — it's attached to the task as a note. The task status is set to pending, which in our status model means "I'm done, waiting on someone else." The agent leaves a second message in the thread and clocks out.

The whole run took two minutes, and it happened after I fell asleep.

08:00 — I come online, and only judge

My review interface is just the task detail page: the draft in a note, the context in the description, the agent's work log in the comment thread. I don't need to open any other tool.

I read the draft and replied with one line in the thread. That line triggered a new agent session — it read the feedback, updated the same note via note_id (not a new note; notes keep full edit history, so a bad rewrite can always be rolled back), then replied in the thread describing what changed.

Back and forth, it feels like collaborating with a remote teammate through a ticket. Except this teammate starts work at 1 A.M. and never complains about rework.

Why the handoff point is a task, not a chat window

The biggest problem with collaborating with AI in a chat window is that output sinks. What it wrote yesterday is fifty screens up today; switch sessions and the context is gone.

Make the handoff point a task, and every part of the exchange gets a native container:

Task description = requirements and instructions (a living document, always current)
Notes = deliverables and process records (an append-only timeline with edit history)
Comments = lightweight conversation (short, threaded, with @ notifications)
Status = position in the workflow (pending means "awaiting review" — one glance at the board shows everything waiting on you)

And humans and AI access all of it through the same entrance. I read on the web and my phone; the agent reads and writes from the terminal via the CLI:

ud describe task 51c4981e      # read the task (notes, comments, attachments included)
cat draft.md | ud apply -f -   # write a note

Because the entrance is CLI + Markdown, the pipeline is not tied to any specific AI tool — Claude Code, Codex, OpenCode, or any terminal-based agent can plug in. Swap the agent tomorrow; the pipeline doesn't change by a single line.

Where else this pattern applies

The blog draft is just the most convenient example. The same loop — "scheduled job / @mention → agent works → notes for the record → pending for review → feedback in comments" — also runs our:

Release verification: after CI ships a version, a task is created with the release notes attached; the agent runs smoke tests and writes results into a note
Daily standup: a scheduled job creates a standup task every day; the agent summarizes yesterday's changes across all tasks
Code research: throw "evaluate option X" at the agent, wake up to a comparison in the notes, ask follow-ups in the comments

There's only one common thread: every step of the AI's work stays in the task, and the human appears only at the checkpoints.

Takeaway

This pipeline uses no concept invented specifically for AI. Scheduled jobs, @mentions, notes, comments, status — all of it is what a task system already has. It's just that when your task system meets three conditions, it naturally becomes a human–AI workbench:

Markdown-native — AI reads and writes without a translation layer
A CLI entrance — any terminal agent can plug in; no vendor lock-in
Status + comments + notes, all first-class — handoff, review, and records each have their place

One more thing: this very post is what the pipeline produced in the small hours of July 12, 2026. The version you just read is the second draft — written after a human replied with a single line: "Too broad. Find one concrete use case and tell it as a story."

Turn Any Web Page into Clean Markdown for Your AI — UnDercontrol Web Clipper

Oatnil — Sat, 11 Jul 2026 02:18:52 +0000

You want to hand a web article to an AI — to summarize it, translate it, or ask questions about it. How do you do that today?

Select-all and copy? You paste a mess of navigation bars, ads, recommendation widgets, and broken formatting. Send the link? Many AI tools can't fetch pages, and when they can, the result is often incomplete.

The UnDercontrol Web Clipper Chrome extension gives you a cleaner answer: click Copy Markdown, and the page's article content is extracted into tidy Markdown on your clipboard — no login, no account, no configuration. Install it and it works on any page. Paste it into Claude, ChatGPT, or any AI, and what it gets is pure content with zero noise.

Copy Markdown: copy, redesigned for the AI era

This is the extension's most-used feature, and it doesn't depend on an UnDercontrol server at all:

One-click copy: the page's article content lands on your clipboard as clean Markdown
Smart extraction: powered by Readability + Turndown — ads, navigation, sidebars, and other non-content elements are stripped automatically
Zero barrier: no sign-up, no login; works instantly on any page
Robust: heavy elements like video and canvas are skipped automatically, so complex pages won't drag your browser down

Markdown is an AI's native language — clean structure, no markup noise. For the same article, pasting Markdown instead of a raw select-all copy gets you noticeably better comprehension and answers, and saves tokens too.

Save to Local: archive without logging in

Local save also works without any login. One click downloads two files:

A complete HTML snapshot: built on the open-source SingleFile, it inlines HTML, CSS, images, and fonts into a single self-contained file that opens offline, exactly as the page looked
The extracted Markdown: the same clean article content that Copy Markdown produces

Links rot and pages get redesigned, but a snapshot is forever the page as it was the moment you saved it. Archive articles, research material, and time-sensitive pages — no server required.

Save to UnDercontrol: clipping joins your workflow

If you use UnDercontrol (the extension connects via login or an API key — self-hosted instances work out of the box), clipping goes one step further: the page becomes a task.

The Markdown content goes into the task description — readable and editable right inside the task
The HTML snapshot is attached to the task, so you can always reconstruct the original page
From there you get the full task toolkit: tags, kanban boards, links to other tasks, notes for your conclusions
AI agents can reach it: through the ud CLI, Claude Code, Codex, OpenCode, or any terminal-based AI agent can read the task — the description already contains ready-to-use Markdown, so the agent never needs to scrape the web page itself

Here's a task produced by a real clip: the description starts with the source URL, the body is the extracted Markdown, and the full HTML snapshot hangs off the attachments panel:

In UnDercontrol, a task has never been just a to-do item — it's a universal information container. Web clipping is simply one more way for information to enter it.

Bonus: Bilibili video subtitles become transcripts

Web Clipper also ships with Bilibili transcript extraction: on a Bilibili video page, the extension detects the video and lights up a Save Transcript button that turns CC or AI-generated subtitles into a formatted Markdown transcript — download it locally or save it as an UnDercontrol task. Finish a tech talk video, and the transcript is archived in one click; handing it to an AI for a summary is one more.

Typical scenarios

Feed your AI: copy a long article as Markdown and paste it into any AI to summarize, translate, or interrogate — far cleaner than pasting a link or a raw copy
Read-later that actually happens: clip a worthwhile article into a task with a deadline; write your action items into the task notes when you're done
Competitive research: clip competitors' pricing and feature pages into a research board — when they redesign next week, you still hold today's snapshot
Bug evidence: a third-party page misbehaves? Clip a full snapshot onto the bug task; even after the page recovers, the scene is preserved
Video study notes: turn a Bilibili tech video's subtitles into a Markdown transcript — archive it or let an AI distill the key points

Install and configure

Install from the Chrome Web Store. Copy Markdown and local save work immediately with zero configuration; only "save as task" needs a connection to your UnDercontrol server — log in directly, or create an API key (starts with ak_) under Settings → API Keys in the web app.

Honest limitations

Chrome internal pages (chrome://, chrome-extension://) cannot be captured
Full snapshots of pages heavy with dynamic content can take up to 2 minutes
A snapshot is a point-in-time copy — it won't change when the original page does (which is exactly the point)

The Web Clipper browser extension itself is open source under AGPL-3.0: github.com/oatnil-top/ud-chrome-extension.

Wrapping up

Without logging in, it's a clean "web page to Markdown + local archive" tool, born for feeding content to AI. Logged in, every clip lands in a task system with tags, kanban boards, and AI-agent access. Next time you want to hand a web page to an AI, try Copy Markdown first.