Rambling Rows

Taming Claude Cowork session sprawl

Sat, 09 May 2026 19:27:00 +1000

Relentless Productivity™ has a dark side. The more capable your tools, the faster the work accumulates - and with Claude Cowork, that accumulation happens session by session, each one spawning its own entry in an ever-growing sidebar list that becomes harder to read by the day.

I know this from experience. My Cowork sidebar had grown to the point where I could no longer tell what was live, what was done and what was waiting. You can pin sessions. You can rename them. But there is no status indicator, no filtering and no way to see at a glance what needs your attention. Managing that list requires discipline, and discipline is not - let’s say - inherent in this particular operator.

So I went back and forth with Claude to work out a better approach.

The problem Cowork creates

Cowork is genuinely powerful. You give it access to a folder on your Mac, describe what you want in plain language and it runs - reading files, executing commands, writing output, co-ordinating sub-agents. It is Claude Code for knowledge workers rather than developers.

But that local-first architecture is also its limitation when it comes to session management.

When you use Claude via the browser at claude.ai, every conversation has a URL. claude.ai/chat/d156fdf3-... - a stable reference you can bookmark, share or link to from a project management tool. The session lives in the cloud and is accessible from anywhere.

Cowork sessions have none of that. They exist inside the Claude Desktop app, operating on files on your local machine. There is no URL. There is no way to reference a specific session from outside the app. The sidebar is the only index you have - and it auto-names sessions based on your first message rather than anything you choose to call them.

The strength of Cowork working exclusively on your local files is, in this respect, the downside.

What we built

The solution has three moving parts: a dedicated tracking directory, a Rocket Typist text expansion snippet and an end-of-session protocol.

Cowork sessions run inside Projects - a workspace layer that lets you attach specific folders to a session so Claude can read and write files within them. That folder attachment is where the session management system hooks in.

The Tracker directory

The first instinct was to attach a general ~/Documents/Claude/ folder to every Project, giving each session access to a shared log. That’s the wrong call.

Attaching a broad directory gives every Project session visibility into everything in that folder - files from other projects, notes, work in progress. Cowork is sandboxed by design, and for good reason. You don’t want a session working on your Acme Corporation board report to be able to read files from a personal task session, even accidentally.

The right approach is a dedicated ~/Documents/Claude/Tracker/ directory. It contains exactly two files - a session counter and a sessions log - and nothing else. When you attach it to a Project, you are giving that session a narrow, read-write window into tracking data only. No cross-contamination. No unintended exposure.

Create it once:

mkdir -p ~/Documents/Claude/Tracker

echo "0" > ~/Documents/Claude/Tracker/session_counter.txt

printf "| ID | Date | Project | Brief | Status | Outcome |\n|---|---|---|---|---|---|\n" > ~/Documents/Claude/Tracker/sessions.md

Every new Cowork Project gets two folder attachments: the project working directory and ~/Documents/Claude/Tracker/. That second attachment is the constant.

The Rocket Typist template

Rocket Typist is a macOS keystroke expansion tool. You define a short abbreviation - I use ;cw - and it expands to any block of text you choose when typed anywhere on your Mac, including in Cowork’s composer.

The template I push in at the start of every session:

Before anything else: read ~/Documents/Claude/Tracker/session_counter.txt, 

increment by 1, write back, append one row to 

~/Documents/Claude/Tracker/sessions.md (columns: ID / Date / Project / Brief / 

Status=Active / Outcome=blank). If ~/Documents/Claude/Tracker/ is not 

accessible, stop immediately and say: "TRACKER NOT MOUNTED — add 

~/Documents/Claude/Tracker/ to this Project before continuing." Then output: 

RENAME THIS SESSION TO: #N [one-line task summary] — then proceed with the task.



When I say "end session": update this session's row in 

~/Documents/Claude/Tracker/sessions.md — set Status to Done, write a 

one-sentence Outcome. Confirm: "Session #N closed."



Task:

You type ;cw, the template appears, you write your task on the final line and send.

Cowork reads the counter file, increments it, writes the new value back, appends a row to sessions.md and then - critically - outputs a rename string: RENAME THIS SESSION TO: #3 Review Acme Corporation Q2 capacity model. You copy that, right-click the session name in the sidebar, rename it, and the session is now findable by number for the rest of its life.

When you are done, you type “end session.” Cowork updates the sessions log row, sets Status to Done and writes a one-sentence outcome. The log becomes a running record of what was actually accomplished.

What the log looks like

| ID | Date       | Project     | Brief                          | Status | Outcome                                    |

|----|------------|-------------|--------------------------------|--------|--------------------------------------------|

| 1  | 2026-05-09 | Personal OS | Weekly Review protocol scan    | Done   | 16 open threads identified; rollup confirmed|

| 2  | 2026-05-09 | Acme Corp   | Q2 capacity model review       | Active |                                            |

| 3  | 2026-05-10 | Palim       | Scope sudoku whimsy feature    | Done   | Feature scoped; implementation deferred    |

A quick look at sessions.md tells you everything the Cowork sidebar cannot: what is live, what is closed and what was achieved.

When volume grows: the GitHub path

This system handles tens of sessions cleanly. If you are running dozens of concurrent workstreams - across projects, domains and time - the flat sessions log starts to show its limits.

The natural escalation is GitHub Projects, which gives you a proper Kanban board. Each session becomes a GitHub Issue. Columns map to session states: Backlog, Cowork Active, Claude Code Queue, Review, Done. You reference sessions by issue number (#42) rather than the counter above, and the Cowork session number goes into the issue body alongside the claude://cowork/new?q=...&folder=... deep link that re-opens a fresh session with the task context pre-loaded.

This also opens up the Claude Code integration path. Some tasks that start in Cowork are better finished in the terminal - file batch processing, code generation, scripted output. A GitHub Issue card flagged claude-code can be picked up by a small bridge script that pipes the task brief to claude --pipe, writes the result back as an issue comment and moves the card to Review. The Kanban becomes the dispatcher for both Cowork and Claude Code.

That is a bigger build. For most people the sessions log is enough.

A word on where this is going

Anthropic will work this out. The current Cowork interface was clearly built for focused, single-session work. As people use it at scale - running multiple projects, juggling parallel workstreams - the demand for better session state management will become impossible to ignore.

A status indicator on each session in the sidebar. A filter for Active versus Done. A Kanban or nested view. These are obvious features, and they will come.

Until then, a text expander, a counter file and a narrow Tracker directory get you most of the way there.

The setup described in this post requires a paid Claude plan (Pro, Max, Team or Enterprise) and the Claude Desktop app for macOS or Windows. Rocket Typist is a paid macOS app available at witt-software.com. GitHub Projects is free for public repositories and included in paid GitHub plans.

PS. This is another example of using AI tools not just to do work, but to diagnose problems with how you work - and then to build systematic approaches that make future performance more reliable. The conversation that produced this post was not “write me a blog post.” It was a back-and-forth that identified a real friction point, explored the constraints of the tool, and arrived at something that actually holds together.

The human is still required throughout. These are semi-sentient actors that will cheerfully proceed in the wrong direction if you do not hold them to account. The system only works because someone noticed the sessions were getting out of hand, cared enough to fix it and kept pushing until the solution was sound. That part does not automate.

Another day of relentless productivity

Mon, 04 May 2026 19:51:07 +1000

As I prepared to race out the door this morning, I snatched up the hand-scribbled agenda for the team meeting and thought: “Oh, at a minimum, I should photograph this.” So I don’t lose the piece of paper.

The next thought was: “Hey, I should send this to Claude.”

Before I knew it, Claude had read it and turned it into a proper document - ready to throw into the stack for the day ahead.

On the way to the office, I realised I’d have to come up with a short board briefing on a particular scenario that was proving, shall we say, a little tricky. I was clear about what I wanted to say, but I wasn’t sure when I’d get time to put it all together before the briefing pack went out.

At the next red light, I tapped record on my Apple Watch and started dictating - the scenario, where we’d got to, what I needed the board to understand. By the time I arrived at the office, the transcript was sitting in my email.

Tossed that at Claude. “Turn this into a brief board-level briefing.” Still trying to stop saying ‘please’ to AI agents - that just burns tokens.

Moments later, I had exactly what I needed.

Absolutely mind-blowing. I can’t believe how good these tools are and how empowering they can be. Mind-blowing also in a very literal sense - it is lucky the phrase hasn’t been acquired by the Mind-Blowing Corporation, because I would be paying a fair licensing fee virtually every day in this age of super-smart AI helpers.

One thing I particularly cannot get over: how well Claude reads my handwriting. At times, even I can’t decipher it.

The dictation-to-transcript magic on the watch is Whisper Memos - available for iPhone and Apple Watch. Highly recommended.

Cowork demonstrated Cowork

Thu, 23 Apr 2026 21:59:48 +1000

A friend of mine, let’s call her Jane, runs a marketing consultancy. Fifteen years in, small team, strong client list, had used Claude for chat only. I offered to spend an hour showing her what’s possible now we’re well beyond that.

Wednesday night I realised winging a 75-minute demo next morning would burn too much time on navigation and too little on value. I opened Claude Cowork, uploaded a brief I’d quickly hacked together from emails and went on with my evening. In just a short time Cowork literally worked magic!

What I asked for

The brief asked Claude to build everything I’d need to run the session.

A slide deck in the consultancy’s own visual style. Speaker notes with live demo prompts. A subscription recommendation with Australian pricing. A 30/60/90-day roadmap. A homework checklist under two hours of her time. And a custom voice skill distilled from the consultancy’s website, so that anything Claude drafted for them afterwards would write in their voice rather than generic consultancy mush.

The live demo scenarios were the hard part. Three of them.

Synthesising customer feedback from focus groups where the inputs are a mess (handwritten notes, scanned post-its, voice transcripts). Identifying adjacent niche markets for a consultancy that mainly grows through word of mouth. Turning around new-business proposals at pace using the consultancy’s distinct voice.

Plus a home scenario. A family with three sons aged 16, 14 and 12 trying to race through a busy Melbourne week without losing their minds.

What came back

Thirty-eight minutes later, Claude had produced three coordinated artefacts.

A 28-slide PowerPoint deck in the consultancy’s visual style. Three-act structure (foundations, deep dives, next steps), embedded demo prompts, subscription comparison, roadmap, homework and a closing slide. All laid out. No placeholders.

A 12-page facilitator Word document. Per-slide speaker notes, copy-and-paste prompts for each live Claude moment, full resource section with hyperlinks, agenda table with time budgets, pre-meeting checklist.

A voice skill as a separate markdown file. One hundred and fifty lines of vocabulary, structural moves, tone calibration (warm not saccharine, frank not blunt) and before-and-after examples. Drop it into the Claude skills folder and the output sharpens on the next prompt.

All of this produced in 38 minutes on a Wednesday evening while I busied myself with other things. I slept well knowing Thursday’s session was effectively ready.

Small cracks, and the choice not to polish

Opening the files felt like being a kid at Christmas. Wow. On the mark. Well past “useful first draft” and into “this could ship”.

Three minor issues. The brand header sat against the logo in a way that slightly muted it. One date was wrong (my fault, I’d put it in the brief that way). A handful of slides had text sitting a fraction too close to decorative elements. Small stuff.

I fixed none of it.

I left the PowerPoint exactly as Claude delivered it. The whole point of the session was to show what this tool actually produces on a brief and polishing would quietly have sanitised the demo into something slicker than the reality. Jane saw the real output, not a glossed version of it.

Arthur C. Clarke’s third law kept running through my head: any sufficiently advanced technology is indistinguishable from magic.

What one demo became

The family scheduling exercise is the easiest of the four demos to show, and it’s a useful window into how deep a single session can go. What started as “help us run a busy week with three boys” became something more interesting as we engaged with Claude.

Three pieces, working together.

A proper calendar architecture. Not “use a shared calendar”, which is the generic advice. Claude came in with seasoned experience on how to build and connect a tier of Google Calendar accounts to cater for the different needs across a family of five. Who sees which layer. Who can edit. Which child maintains their own calendar with partial visibility back to the parents. Colour coding, sharing rules, and the quiet discipline of if it’s not on the calendar within the hour, it didn’t happen. This is the sort of advice you’d pay a family coach serious money for. It arrived inside a minute.

A 15-minute Sunday meeting. The Sync — a weekly family huddle with its own guide. The clever move: a second version written directly to the kids, opening with “Hey you three” and framing the ritual as the family’s shared discipline rather than a compliance exercise. That distinction matters when two of your kids are negotiating their teen years and own identities. The meeting runs against a short template to keep it on the rails.

The week at a glance. A one-page live HTML view showing the coming week on the kitchen iPad. Who’s where, when, who’s driving. Updates when the calendars change.

This is not what “a family scheduling plan” usually means. This is a household operating system, designed for a real family with real teenagers. One exercise, inside one session, unlocked what would have been a weekend of work with a human family coach.

The late encore

Fifteen minutes before the session was due to start, I had another thought. Always dangerous.

The speaker notes carried a time budget per slide. How was I going to hold pace without glancing at my laptop clock every thirty seconds and looking disengaged on the Zoom call?

“Take the Word guide. Pull the time budget per slide. Build me an interactive HTML dashboard I can run on my iPad. Something I can see at a glance."

First build came back in dark theme (Claude defaulted to dark, because most developers want that). Wrong for this use case. “Light theme, clean.” Rebuild in under a minute.

Next problem. An iPad doesn’t host HTML well. You can’t reliably open a local .html from the Files app and have it render. I raised this with Claude. Three suggestions came back. The fastest was Netlify. Drag the folder onto the browser, get a live URL, open on the iPad. Free. Thirty seconds to deploy.

Ten o’clock came around. The Custom Presentation Pacer ticked silently on the iPad beside my laptop. It worked really well to keep me on track. Not too fast, not too slow.

The session

Seventy-five minutes became ninety, in the good way.

The live Cowork demos landed. The family scheduling exercise produced the operating system I described above, on screen in front of Jane. The adjacent markets conversation named sectors and organisations neither of us had thought about before the session started. The voice skill was the quiet hit. Jane saw her own website phrasing come back in a draft email inside 90 seconds and went quiet for a moment.

Afterwards I sent her the full pack. Deck, speaker notes, voice skill, zipped. And an email explaining what she’d just watched: a Claude session prepared by Claude, deliberately unpolished, delivered with a real-time HTML tracker that Claude also built from the same source materials fifteen minutes before we started.

The meta-point landed. Jane got it straight away.

The point

There is a version of this story that is about the prompt I wrote. A better version is about everything else.

38 minutes.

One brief, one upload, one evening. In less time than it takes to cook dinner, Claude read a brief, asked a handful of clarifying questions and produced a 28-slide deck, a 12-page facilitator document and a 150-line voice skill — three separate formats, one coherent voice, no placeholders, no lazy defaults.

Claude didn’t replace my judgment. It did everything a competent producer-designer would have done over three full days of effort. In the time it took me to cook dinner and watch half an episode of something.

The magic isn’t that Claude writes a deck. Lots of tools write decks now. The magic is the coordination. A deck and its matching speaker notes and a voice skill that makes both sound like the client. Plus, when the family scheduling exercise happened on Thursday, another household-scale operating system, designed from scratch, inside the session window.

Cowork demonstrated Cowork. I pointed at the screen and said watch this.

Sources:

Claude Cowork (claude.com)
Netlify (netlify.com)
Arthur C. Clarke’s Third Law — from Profiles of the Future, 1973