DEV Community: Oatnil

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.

Tags and Custom Fields: Organize Tasks by Your Own Dimensions

Oatnil — Thu, 09 Jul 2026 13:11:19 +0000

Most tools decide for you what a task "looks like": a few fixed dropdowns, a hard-coded set of fields, someone else's taxonomy. But in reality every person, every team, every workflow wants to track different dimensions — one needs "priority", another needs "client", "estimate", "department", and someone else just wants to slap on a tag and filter later.

UnDercontrol doesn't impose structure. It gives you three composable layers: free-form tags, typed custom fields, and arbitrary key-value metadata. All three are directly queryable, so you can slice the same set of tasks along your dimensions instead of bending to the tool's taxonomy.

This rests on a core UnDercontrol idea: a task is not just a to-do — it's a universal container for information. The same Markdown editor runs across tasks, notes, expenses, and accounts — every text surface. Tags and custom fields are how you layer your own structure on top of that container.

1. Free-form tags: the lightest way to organize

A tag is just free text you jot down — no predefined vocabulary, write whatever you want (work, urgent, client-acme, bug, all fine).

Autocomplete built in: as you type, suggestions come from tags you've used before (ordered by recency) — free-form, yet you won't misspell or spawn ten spellings for one concept.
Batch tagging: on the task search page you can add or remove tags across a batch of tasks at once, no need to open each one.
Not only on tasks: tags also apply to resources (uploaded files), so you can thread files and tasks together with one shared vocabulary.

Tags themselves are a queryable array field:

tags CONTAINS 'work'                   -- has the work tag
tags IN ('work', 'personal')           -- has work or personal
tags CONTAINS_ALL ('work', 'urgent')   -- has both work and urgent

Typical scenario: a batch of related tasks lands on you — slap a shared q3-launch tag on all of them, then aggregate them from any board with tags CONTAINS 'q3-launch'. When the push is done, keep the tag as an archival breadcrumb, or batch-delete it.

2. Custom fields: typed, structured dimensions

Tags solve "attach a word". But when what you track has a type and a value range — priority is a number, department is a fixed set of options, owner is a specific member — reach for custom fields.

On the Custom Fields page (/custom-fields, also reachable from a task's properties, the kanban menu, or the command palette) you define a field and pick its type:

Text — free text value
Number — numeric, supports comparisons
Select — a fixed set of options you list up front
Checkbox — a yes / no boolean
User — pick a member from your workspace

You can also mark a field required. Once defined, the field shows up in task detail for inline editing, and the value is stored on that task.

Scope a field by tag

Here's the key design choice: a custom field doesn't have to apply to every task. When you create a field you pick its scope:

All tasks — every task shows this field
Tasks with specific tags — only tasks carrying the chosen tags show the field

So "tags" and "custom fields" mesh naturally: a task's detail page only surfaces the fields that match its tags — irrelevant fields stay out of your way. Tag a task bug and "repro steps" / "severity" appear; tag it sales and "client" / "amount" show up instead.

Typical scenario: a team runs "engineering bugs" and "sales follow-ups" side by side. Scope the bug fields to the bug tag and the sales fields to the sales tag. In one board, each kind of task shows only its own field set, with no cross-talk — no need to split into two systems.

3. Arbitrary key-value: for the ad-hoc and the off-schema

Not every piece of metadata is worth defining a field for. Task detail also has an extra metadata section where you drop arbitrary key-value pairs on a task (e.g. jira: PROJ-123, source: customer email) without declaring anything in settings first.

This layer is the buffer between "free tag" and "formal custom field": jot it down first, and once a key gets used often enough to become a stable dimension, promote it to a typed custom field.

Typical scenario: tasks synced in from an external system carry a pile of loose fields (ticket number, source link, external ID) — stash them as key-value pairs verbatim. Whichever key later turns out to need frequent filtering, formalize it into a custom field.

4. Querying them: the `cf.` prefix and kanban columns

The real leverage of custom fields is that they're queryable just like built-in fields. Reference a custom field in a query with the cf. prefix:

cf.priority > 5                          -- priority above 5
cf.priority IN (1, 2, 3)                 -- priority is 1, 2, or 3
cf.department = 'engineering'            -- engineering department
cf.priority IS NULL                      -- tasks with no priority set
cf.priority > 5 AND status = 'todo'      -- high-priority todos
cf.priority > 5 ORDER BY updated_at DESC -- high priority, newest first

Custom fields combine freely with built-in fields (status, tags, deadline, …) in one query. And in UnDercontrol, every kanban column is essentially a saved query — so you can build a column called "High-priority todos" whose condition is cf.priority > 5 AND status = 'todo', and any task that matches drops into it automatically, no manual dragging. The task search page can surface custom fields as columns too.

Typical scenario: build a "by client" board for the team, one column per client, each column's condition cf.client = '...'; a new task snaps into place the moment its client field is filled. The same set of tasks becomes "by priority" or "by department" with a different query — the view follows the dimension, the data stays single-source.

Wrap-up

UnDercontrol doesn't decide which dimensions your tasks should have — it hands you three layers to stack from light to heavy as needed:

Free-form tags — zero-cost, jot-and-go, batchable, autocompleted
Custom fields — typed (text / number / select / checkbox / user), optionally required, and scopable by tag
Arbitrary key-value — for ad-hoc and off-schema info, promotable to a real field anytime

The common foundation under all three is one query language: tags CONTAINS_ALL(...), cf.priority > 5, freely combined with built-in fields, then frozen into kanban columns. The same set of tasks, sliced however you like — the structure is yours, not the tool's.

All of this rests on UnDercontrol's "a task is not just a to-do" idea: one unified information container, one editor across every text surface, plus tags and fields that let you define your own dimensions. Pair it with Claude Code, Codex, OpenCode, or any terminal-based agent to read and write this structured data — but you always keep the wheel on how it's organized.

Everything is a Task: One Container for To-dos, Docs, Notes, and a Knowledge Graph

Oatnil — Wed, 08 Jul 2026 06:59:47 +0000

Unix has a famous design philosophy: everything is a file. Directories, devices, pipes, sockets — all read and written through one uniform interface. Simple, unified, composable.

UnDercontrol borrows the same idea, just with a different primitive: everything is a Task.

Most tools treat a "task" as a single line with a checkbox. UnDercontrol never did. Here, a Task is a universal information container — it can be a to-do, a document, a reminder, a blog draft, meeting minutes, a decision record, even a wiki page. One data source, organized your way, all in one place.

You don't hop between apps; an AI agent needs just one tool to reach everything you have.

Three content layers

Every task is made of three layers, each with a design intent — but you're free to use them however you like:

Layer	Format	Design intent
Task body	Markdown	The living, canonical document — the Single Source of Truth
Notes	Markdown	An append-only timeline — how this unit of information evolved
Comments	Plain text	Lightweight, threaded discussion — short and focused

The body is a living document where you keep the complete, coherent narrative; notes record progress over time (session start, each commit, blockers hit); comments are the quick conversation around the content. Clean separation — and all plain text, so both humans and AI read it directly, with no conversion.

A single task detail page makes the point: it's not one line of to-do, but a living document with a Markdown body, tags, status, deadline, a notes timeline, subtasks, and a relation graph.

One content, many views

Because there's only one primitive underneath — the Task — UnDercontrol can offer many views over the same data, switchable anytime:

List view: linear and filterable, great for scanning and batch work
Kanban view: drag cards to change status, manage in-flight workflow visually
Calendar view: laid out by deadline, so timing is obvious at a glance
Tree view: expand parent-child relationships to see the hierarchy
Graph view: traverse links, parents, and subtasks as a graph to see how knowledge connects

A board isn't "another container" — it's essentially a saved query. The same task can appear on many boards at once, with zero duplication. You change the perspective, not the data.

Six statuses that match real workflow

Tasks support six statuses that fit how real work moves: todo, in-progress, pending (awaiting confirmation/review), done, archived, and stale. Dragging on the board updates status automatically — and status itself is information: one glance tells you where everything stands.

Tell things apart with tags and metadata, not folders

If everything is a task, then a "document" and a "to-do" are structurally the same thing. What sets them apart is never the structure — it's tags, metadata, and views. UnDercontrol forces neither a tagging convention nor a folder hierarchy on you:

Tags: free-form labels you define (doc, meeting, reminder — anything)
First-class metadata: title, status, tags, deadline, assignee, links — the 20% that covers 80%
Custom metadata: unlimited key-value pairs (doc_type: rfc, client: acme), all queryable too

When you need precise retrieval, UnDercontrol also gives you a SQL-like query language and natural-language queries — save common conditions as board columns and complex filtering is one step away.

Virtual folders + AI: organize information like files

Prefer a "folder" style of organizing? UnDercontrol has that too — virtual folders. Every task carries a path field (a virtual path, a first-class part of the schema, e.g. /Work/Alpha/) that adds up to a familiar file tree in the app; drag to file things away. An empty path means "unfiled", / is the root, /Work/Alpha/ is a specific folder — and it's not just tasks: resources (attachments), skills, and other entities share the same virtual paths, placed in one tree.

It even syncs between local and cloud like Git: ud pull /Work/Alpha/ checks a virtual directory out into a local folder (creating a .ud/ to hold sync state, just like .git/), edit it with whatever editor you like, and ud push sends it back. To move a folder, just move it locally and ud push updates the cloud path.

What makes organizing truly effortless is adding AI. Because the whole structure is plain text plus paths, an AI agent can read your full picture and tidy it up for you:

"Move all these scattered meeting notes under /Meetings/2026-Q3/" — the AI rewrites paths in bulk, one sentence
"Organize this project's tasks into a clean folder structure" — the AI reads the content, decides where things belong, and reorganizes
"Split this into subtasks and archive the old ones" — the AI handles the splitting, filing, and status changes together

Claude Code, Codex, OpenCode, or any terminal-based agent can do this through one uniform CLI. You do the thinking; the AI puts information where it belongs.

Bi-directional links: weave tasks into a knowledge graph

Tasks can connect in several ways: peer links relate two things; parent/subtask relationships break a big goal into executable steps. With the graph view, your task base becomes a traversable knowledge network rather than a pile of isolated entries.

Inside the body, notes, and comments you can also reference other entities with Markdown links — another task [Title](task://...), a note [## Heading](note://...), an @mention [@name](mention://member/...), even an embedded uploaded image ![shot](resource://...). The whole base is interconnected.

Not just tasks: one editor across every text surface

"Everything is a task" has one more layer: UnDercontrol's Markdown editor is not task-only — it's reused everywhere you write in the app: task bodies, notes, even the memos on finance records (expenses, accounts). The editing experience, Markdown syntax, and embedded links and images you know from tasks are identical elsewhere. Learn it once, use it everywhere.

Attachments and collaboration

Tasks let you drag files in or paste from the clipboard — screenshots, design mockups, documents stay next to the task they belong to. Storage can be local or S3-compatible object storage; your data stays under your control.

For collaboration, tasks are shared through groups with role-based read/write permissions. The same task can appear on a shared board where teammates discuss and update progress — you share the information, not your whole account.

Typical scenarios

Personal knowledge base: keep meeting notes, decision records, and reading notes all as tagged tasks; retrieve them anytime with queries and boards — one app holds it all.
AI agent collaboration: Claude Code, Codex, OpenCode, or any terminal-based agent reads and writes tasks, appends notes, and records progress through one uniform CLI — human and AI share one source of truth.
Product/engineering pipeline: requirements in the task body, progress in notes, review comments in comments; track status flow on a board and see dependencies in the graph.
Content creation: a blog's Chinese draft, English draft, and social copy each live as a note; the task itself is the Single Source of Truth, and everything published outward is derived from it.

In summary

Everything is a task — not just a slogan, but UnDercontrol's underlying design: a Markdown-native, AI-ready universal container, with many views, six statuses, bi-directional links, flexible tags and metadata, and one editor across the whole app. No more shuttling things between a to-do tool, a notes tool, and a docs tool — it all belongs in one place.

Start here

🏠 Website & docs: oatnil.com
📦 CLI installation guide: oatnil.com/docs/cli
💻 Desktop App & self-hosting: oatnil.com/subscribe

One universal container, one home for all your work — try it now with npm install -g @oatnil/ud.

Manage Your Tasks Like git: ud pull / push Local Bidirectional Sync

Oatnil — Tue, 07 Jul 2026 00:46:37 +0000

In one sentence: ud pull checks your cloud tasks, notes, and attachments out as local Markdown files, and ud push sends your local edits back. As natural as git clone and git push.

Many working copies, one server, edit from anywhere.

Why we built this

UnDercontrol has always been built on one core belief: your data is yours. Tasks, notes, ledgers, resources — every piece of text is plain Markdown, never locked into any single app.

But "exportable" isn't enough. What developers actually want is to treat that content as local files — edit it with their favorite editor, feed it to AI tools, and sync the changes back when done.

So we built a git-style command-line sync: ud init / ud pull / ud push / ud status. There are no new concepts to learn — if you know git, you already know how to use it.

Three commands, the exact same mental model as git

ud command	git equivalent	What it does
`ud pull /Work/Alpha/`	`git clone`	Check a cloud virtual directory out into the current folder and bind them
`ud status`	`git status`	See what changed locally and remotely
`ud push`	`git push`	Push local changes back to the cloud
`ud init /Work/Alpha/`	`git init`	Publish an existing local folder as a cloud directory

The first ud pull /Work/Alpha/ binds the current directory to the virtual path /Work/Alpha/: a .ud/ folder appears to hold sync state (just like .git/), and the contents of /Work/Alpha/ land directly in the folder. Every ud pull after that is incremental — only changed items are downloaded.

# In an empty folder, init + checkout in one step
ud pull /Work/Alpha/

# Later: incrementally pull all tracked paths
ud pull

# See what changed on both sides
ud status

# Push local changes back (shows a change list for confirmation first)
ud push

What it looks like locally: a task is a folder, a note is a file

The checked-out structure exactly mirrors the virtual folder hierarchy inside UnDercontrol:

Alpha/
├── .ud/                      # sync state (like .git/)
│   └── tracking.json
├── Design-Doc/               # one task = one folder
│   ├── index.md              # task body (YAML frontmatter + description)
│   ├── Kickoff-notes.md      # every note = one .md file
│   └── Review-notes.md
├── Sprint-Plan/
│   └── index.md
└── architecture.png          # resources = plain files, placed by virtual path

Open index.md and it's clean Markdown:

---
id: 8f3c...
title: Design Doc
status: in-progress
tags: [design, alpha]
deadline: 2026-07-20
---

## Background
The task description body goes here…

A few deliberate design choices:

Content is stored verbatim — in-app links like resource://, task://, and note:// stay exactly as they are. Sync is a byte-level round-trip; your content is never rewritten.
The virtual path is not written into frontmatter — the folder's location on disk is the single source of the path. Want to move a task to another directory? Move the folder locally, and ud push updates the cloud path.
File names are sanitized, with the original names kept in .ud/tracking.json — special characters and non-ASCII names are handled for you.

On push, ud figures out what you did

ud push compares your working directory against the "last known state" in .ud/tracking.json, item by item, and infers the right action:

What you did locally	What ud push does
Created a task folder (with index.md), or a loose `.md`	Creates a task
Added a new `.md` inside a task folder	Creates a note on that task
Added a non-`.md` file	Uploads it as a resource
Edited index.md / a note / a resource file	Updates it in the cloud
Moved a file/folder to another directory	Updates the cloud virtual path
Deleted a file/folder	Soft-deletes in the cloud (recoverable)

In other words: create a My-Idea.md file locally, run ud push, and it becomes a task in UnDercontrol. And the other way around: a task created in the cloud shows up locally after ud pull. Truly bidirectional.

Conflicts: like git, nothing gets silently overwritten

If the same task was modified both locally and in the cloud, ud marks it as a conflict:

ud push skips conflicting items by default (and tells you to pull first), or use --force to overwrite the cloud.
ud pull keeps the local version by default, or use --keep-remote to let the cloud win.
In an interactive session, it asks you item by item which version to keep.

Run ud status first, then decide — no data is ever silently lost.

Many working copies, one server, anywhere

In git's model, one origin can have any number of local clones. ud works the same way — on top of one server, you can have any number of local tracked folders, each bound to a different virtual path:

Laptop              Desktop            Another Mac / server
~/work/alpha  →     D:\notes\alpha  →   ~/proj-x
  binds /Work/Alpha/   binds /Work/Alpha/  binds /Projects/proj-x/
        \                 |                    /
         \                |                   /
          ┌──────────────────────────────────┐
          │      one UnDercontrol server      │
          │ (virtual folders = source of truth)│
          └──────────────────────────────────┘

This buys you a few very practical things:

One repo per place, fully independent: /Work/Alpha/ and /Projects/proj-x/ are separate tracking roots, each with its own .ud/ state. Check out only the slice you care about right now instead of pulling your entire knowledge base.
View and edit from anywhere: on any device, ud pull gets you the latest, and ud push syncs your edits to everyone and every client. On your phone? Just open the Web or desktop App — same server, same data.
Humans and AI share one source of truth: you edit in Obsidian on your laptop, an AI agent edits via the CLI on a server, teammates edit in the App — everything converges on the same virtual path on the same server, and ud status always shows who changed what.

In short: the server is the single source of truth, and local folders are just its working copies. It's the model git has validated for twenty years — applied to your tasks and knowledge base instead of code.

Not just tasks: your whole knowledge base as files

This part matters: UnDercontrol's Markdown editor is shared across every text surface — tasks, notes, even the memo fields on expenses and accounts are all the same Markdown. So what ud pull checks out isn't an isolated "todo-list export" — it's a local mirror of your entire knowledge base, ready to be opened, edited, and pushed back with any tool.

Typical scenarios

Manage tasks in Obsidian / VS Code: ud pull into your vault, enjoy your familiar editor, keybindings, and plugins, then ud push when done.
Let AI agents read and write your tasks directly: hand the synced folder to Claude Code, Codex, OpenCode, or any terminal-based agent — it can read task context, append notes, even batch-create tasks, because to the agent they're just ordinary local .md files.
Keep tasks next to your code: run ud init /Projects/proj-x/ in the project root and version design docs and decision records right alongside the code.
Write offline: edit local files on a plane or in the subway; one ud push syncs everything once you're back online.
Local backup: a single ud pull is a plain-text, human-readable, never-expiring full backup.

Get started in three steps

UnDercontrol is a workbench that puts tasks, knowledge base, and AI agents in one place, with a desktop App and self-hosting support — your data stays private, portable, and yours.

1️⃣ Install the CLI (30 seconds)

npm install -g @oatnil/ud
# Don't want to install? Use npx:
npx @oatnil/ud --help

2️⃣ Pull, then edit with whatever you like

ud pull /Work/     # check a virtual directory out locally
ud status          # see what changed on both sides
ud push            # push it back

3️⃣ Grab the desktop App / self-host your own server

Want a GUI, multi-device access, or the whole server running on your own machine? See the links below.

Start here

🏠 Website & docs: oatnil.com
📦 CLI installation guide: oatnil.com/docs/cli
💻 Desktop App & self-hosting: oatnil.com/subscribe

Your data, your format, your tools. UnDercontrol just makes them flow — try it now with npm install -g @oatnil/ud.

Everything as Code: When Your Tasks Become Markdown You Can Commit to Git

Oatnil — Mon, 06 Jul 2026 00:13:04 +0000

We've all gotten used to "X as Code" — infrastructure as code, configuration as code, docs as code. The reason is simple: plain text can be diffed, reviewed, version-controlled, and read or written directly by scripts and AI.

So why are your tasks, notes, and todos still locked inside some SaaS database, reachable only by clicking through its UI one item at a time?

UnDercontrol's answer is Everything as Code. Here, a task is a piece of Markdown with YAML frontmatter. That's it.

What a Task Looks Like

---
title: Add a smoke test to the release flow
status: in-progress
tags: [release, testing]
deadline: 2026-07-10
---
## Goal
Run the critical path automatically before every release; block the tag on failure.

## Steps
- [x] Log in + create task
- [ ] Browse the three core pages
- [ ] Assert no console errors

The frontmatter is the task's structured metadata: title, status, tags, deadline, assignee, links — the 20% of fields that cover 80% of cases are all first-class, and all queryable. The body below the frontmatter is the task's canonical document (the Single Source of Truth): a living piece of Markdown.

No proprietary format. No binary blob to export. No vendor lock-in. What you see is all there is.

apply, Just Like kubectl

Save that Markdown to a file, then:

ud apply -f task.md

The rules are exactly like kubectl apply: no id in the frontmatter means create, an id means update. apply is a full replace — the file is the source of truth.

Want to export in bulk, edit, and push it all back? ud get task -o apply prints your tasks in the same format apply accepts — a lossless round-trip. That means your task list can be processed like code with sed / jq / any script, then applied back in one shot.

Why This Is a Superpower for Developers (and AI)

1. Version-controllable, GitOps-friendly. Tasks are plain text, so they naturally diff, live in Git, and go through PR review. Your project plan and your code can share the same commit history.

2. Native I/O for AI agents. Markdown is human-readable and AI-readable. Any terminal-based coding agent — Claude Code, Codex, OpenCode, or any agent that lives in your shell — can read and write your tasks directly through the ud CLI, with no special plugin or SDK. The whole knowledge base is plain-text-native and AI-ready.

# things an agent can do right in your terminal
ud get task 'status = in-progress'
ud apply -f new-task.md
ud describe task 8b30140e

3. Scriptable and composable. A SQL-like query syntax plus kubectl-style verbs (get / describe / apply / delete / patch) turn task management into something you can drop into any automation. Create a task in CI, bulk-retag from a script, generate a weekly report from cron — each is just a few lines of shell.

Not Just Tasks

Here's a detail that's easy to miss: UnDercontrol's Markdown editor is not task-specific. It's a single editor shared across every text surface — tasks, notes, even expense and account memos all use the same editing experience and the same Markdown core.

So the "Everything" in "Everything as Code" is literal: your todos are Markdown, your notes are Markdown, the memo on an expense you logged is Markdown. One data source, organized the way you like, all in one place. No switching between apps, and an AI agent only has to learn a single tool to reach all of your information.

Three Content Layers

Each information unit has three layers. Each has a design intent, but you're free to use them however suits you:

Layer	Format	Design Intent
Task body	Markdown	The canonical, evolving document — Single Source of Truth
Notes	Markdown	An append-only timeline — how this unit evolved
Comments	Plain text	Lightweight, threaded conversation — short and focused

What distinguishes a "doc" from a "task" isn't the data structure — it's tags, metadata, and the view. UnDercontrol doesn't force a folder hierarchy or a tagging convention on you: the same task can appear on multiple boards (a board is a saved query, not a container, so there's no duplication).

Get Started

If you're tired of trapping your ideas inside a UI, try turning them into Markdown you can apply:

ud apply -f my-first-task.md

Everything as Code isn't just a slogan — it's how your tasks, your scripts, and your AI agents finally speak the same language.

DEV Community: Oatnil

Claude Plans, Codex Executes

Five steps to a working pipeline

Form a squad: Agent Teams

Watch everything live

Typical scenarios

The combo is yours to choose

Virtual Path: Where Tasks Settle into Knowledge and Docs

Give a task a place

Many tasks, one document

Sync it local — offline, and yours

Let an agent tidy your tree

Growing with UnDercontrol: Time Compounds, and So Does Knowledge

Career switchers know what "accumulation" really means

The Joplin era: get things written down (Collect)

The Obsidian era: connect the knowledge (Connect)

UnDercontrol: make knowledge callable (Compound)

Time compounds into strength

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

Why most tools work this way

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

So what about the tuition?

And you don't have to teach the agent either

Drag a card in, and the board makes it true

It knows when not to act

You see the real thing before it exists

Where this shows up

The Monday-morning deadline radar

A team workload view

A content pipeline

The plan changed, so say one more sentence

Once it's built, it's still yours

Your board, your design, none of the homework

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

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

Breaking it down: the UnDercontrol agent workbench

Why "AI can operate the platform itself" matters

Wrapping up

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

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

Tuesday: a card is more than a title

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

Thursday: columns don't have to be statuses

Friday: share the board with your team

The week, in summary

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

A task is not just a to-do item

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

The pipeline: 24 hours in the life of one task

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

Where else this pattern applies

Takeaway

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

Copy Markdown: copy, redesigned for the AI era

Save to Local: archive without logging in

Save to UnDercontrol: clipping joins your workflow

Bonus: Bilibili video subtitles become transcripts

Typical scenarios

Install and configure

Honest limitations

Wrapping up

Tags and Custom Fields: Organize Tasks by Your Own Dimensions

1. Free-form tags: the lightest way to organize

2. Custom fields: typed, structured dimensions

Scope a field by tag

3. Arbitrary key-value: for the ad-hoc and the off-schema

4. Querying them: the cf. prefix and kanban columns

Wrap-up

Everything is a Task: One Container for To-dos, Docs, Notes, and a Knowledge Graph

Three content layers

One content, many views

Six statuses that match real workflow

Tell things apart with tags and metadata, not folders

Virtual folders + AI: organize information like files

Bi-directional links: weave tasks into a knowledge graph

Not just tasks: one editor across every text surface

Attachments and collaboration

Typical scenarios

In summary

Start here

4. Querying them: the `cf.` prefix and kanban columns