An operating loop for AI-assisted work

Why I built this

The scarce resource in AI-assisted work is not output. It is continuity: knowing what matters, what changed, and what needs to happen next.

LLMs let me explore more ideas and move through implementation faster. They also create more places for useful work to evaporate. A task comes up mid-session and never reaches the backlog. A session gets cleared with uncommitted work still in the tree. Friday arrives and I have to reconstruct what the week's AI work actually produced. AI made each session faster while making the gaps between sessions the new bottleneck.

My memory vault fixed decision loss, but remembering is not the same as following through. I needed a lightweight way to turn transient AI work into durable state: important commitments land in one backlog, sessions end with recoverable work, daily status comes from source evidence, and repeated friction becomes visible at the end of the week.

That is the reason for this plugin. It is not an attempt to automate every part of my job. It is a way to make AI's speed compound instead of reset. The loops handle capture and reconstruction so I can spend attention on judgment, collaboration, and the work itself.

The engineering instinct is the same one I bring to reliability work: when a manual step keeps failing, you do not try harder, you build a small system with a clear contract. The productivity plugin is that system: a handful of skills that share one vault and one convention, each small enough to read in a few minutes and reason about completely.

The loop

The skills form a daily-to-weekly cadence around a single git-backed vault. The vault is the only shared state; every skill reads from it and writes plain Markdown back to it, so any one of them works standalone and none of them depends on another's runtime.

flowchart TB
  subgraph capture["In the moment"]
    direction LR
    T["/todo · capture a durable task"]
    W["/wrapup · is it safe to /clear?"]
  end
  subgraph review["Daily → weekly"]
    direction LR
    S["/standup · Jira + backlog → status"]
    D["/daily-wrapup · goals + tomorrow"]
    C["/ai-coach · Friday, report-only"]
  end
  V[("Obsidian vault · Markdown, git-backed")]
  T -->|"append (idempotent)"| V
  W -->|"read state"| V
  V --> S
  V --> D
  D -->|"commit goals"| V
  V --> C
  C -.->|"writes a report, changes nothing"| V
            

Two skills run in the moment, three on a daily-to-weekly rhythm:

/productivity-setup ties it together. It installs managed local copies of these skills for every Claude Code and Codex client it detects, records your vault path in ~/.config/adzuci-productivity/config.json, and offers to schedule the Friday coach with whatever scheduler is native to the client you are in. The plugin also ships /budgetclaw-setup for local spend monitoring and an agent-ops pair for privacy-safe scheduled agents.

Contracts, not vibes

The reason I trust these loops enough to run them on autopilot is that each one has an explicit, testable contract. Three examples worth calling out for an engineering audience:

Design guardrails

The same rules as the memory plugin, because they are the reason the whole thing is safe to leave running:

Everything is plain files. Tasks are Markdown checkboxes in a Kanban board Obsidian renders natively; coach reports are dated Markdown in coaching/. Installs are dry-run first and confirmation-gated: they never overwrite an unmanaged skill of the same name, and every managed copy carries a marker file so updates are safe and removal is obvious. Scheduling uses the client's own scheduler; where there is no good native option, the setup skill hands you the exact manual command instead of quietly writing a cron job. And writes that could compound (task capture, goal commits) are idempotent, so a double-run or a retry never corrupts the board.

What changed in practice

The outcomes I care about are fewer dropped commitments, faster restarts, and evidence I can use to improve how I work. Four months of running this, measured off the vault it writes to:

The SessionEnd hook does the archiving, so those 610 summaries cost me nothing to keep, and I stopped deciding what was worth writing down. On the 19 days with something to reconcile I ran /daily-wrapup, and each one means the next morning starts from a written plan instead of a cold read. Tasks moved out of chat scrollback and into the backlog, because capturing one is now cheaper than scrolling to find it. And the Friday coach reads that same pile and, often enough to matter, names a habit I had not clocked. The loops are small; the state compounds.

Why I am publishing it

The interesting part is not one more personal productivity setup. It is comparing failure modes and better contracts with other people building AI-assisted workflows. I am sharing the working implementation so others can test it, challenge it, and show me better loops. If you are working on this too, open an issue or reach out. If AI leverage, operational rigor, and explicit guardrails sound like your kind of engineering culture, I would enjoy connecting. You may also find Apollo's open roles interesting.

Honest limitations

It assumes the vault convention from the memory plugin: a sessions/ directory of curated notes is what makes the coach useful; without it, weekly mode has little to read. The Kanban layout is an opinion (six fixed sections), not a framework. Scheduling is best-supported on the clients I use daily; elsewhere you get the manual command rather than a background job installed on your behalf. And like everything in this repo, it is tested primarily on macOS; Linux and Windows reports are welcome.

claude plugin marketplace add adzuci/claude-plugins
claude plugin install productivity@adzuci-plugins
/productivity:productivity-setup

codex plugin marketplace add adzuci/claude-plugins
codex plugin add productivity@adzuci-plugins
/productivity-setup