Continue your work across a new thread, without repeating yourself
Re-explaining your own work is the most expensive habit you have. This kills it.
What you'll walk out with
Carry a project across as many threads as it takes.
Pick the mode that fits how you already work: manual, connector, or Cowork.
Build your first skill, so the whole habit runs on one word.
~6 min read · then ~15 min to build it
Callback
The problem
You already know a long thread atrophies. But your inclination is to pick up working in the same thread. Here's the habit that works.
In 1.6 you learned a long thread degrades. It has a size limit. It weighs recent text more.
You learned the signs, and when to start fresh instead of pushing.
And you learned the checkpoint: ask for a handoff before you go, paste it into the next thread.
The checkpoint works. It also depends on you remembering to do it, and doing it well, every single time. That's the part that breaks.
Need a refresh? → 1.6 Conversation Architecture
This page gives the handoff a permanent place to live.
Then it makes one word do the work.
Part A · The doc
The frame
Make your Chief document status
Good project documentation means anyone can pick up the work tomorrow. Including someone who wasn't there.
Back to your new hire from 0.1. Brilliant. Knows nothing about you.
Forget what they know for a second. Look at how a good one operates.
They keep notes, and organize them into one doc they keep current.
Decisions get written down the day they're made.
They never reconstruct where things stand. They already know.
Somebody out sick? Somebody new on the team? They read the doc and start.
Nobody has to go hunt down the person who remembers.
The test of good project documentation: a stranger can pick up the work without asking you a single question.
When you work with AI
Every new thread is a bunch of notes not connected to a workstream.
It wasn't there Tuesday. It has no idea what you decided.
You've been treating that as a memory problem. It isn't.
It's a project management problem, and every well-run team already solved it.
The one difference
A human project manager updates the doc without being told.
Your Chief won't. Not unless you say so.
That's the gap. That's all this page closes.
The build
How to do this
The thread is where the work happens. It is not where the work lives.
So keep the doc a project manager would keep.
Not a transcript. Almost none of it. The transcript is mostly noise.
Keep only what you need to pick up the work.
The status doc
What's decided, what's open, what changed, what's next.
It's what they'd bring to a check-in.
Rewritten constantly. Stays under a page.
It replaces scrolling up.
Status is not a record of what happened. It's a picture of where you are right now, and what's next.
The template
Notice the first paragraph. The doc tells Chief what to do with it. That's not decoration. A doc that carries its own instructions works even before you build anything.
# STATUS — [project name]
**Claude, read this first, every session.** This is the source of truth for
where this work stands. Before we stop, rewrite this file so the next session
starts from an accurate picture. Overwrite the old content, do not append.
Update "Status now," "Done this session," and "Next actions." If anything in
"The basics" changed, fix it too. If I forget to ask, remind me: "Want me to
update the status doc before we stop?"
## The basics
- **What this is:** [one or two sentences: what we're doing, who it's for]
- **What done looks like:** [how we'll know it's finished]
- **Where the work lives:** [doc, folder, repo, tool — with the link]
- **Rules that don't move:** [format, voice, constraints, anything you
keep having to repeat]
## Status now
[Plain language, a short paragraph. What works, what's half-built, what's
untouched. Written so a fresh session with zero memory understands exactly
where things stand.]
## Decisions made (don't re-litigate)
- [decision] — [why]
- [decision] — [why]
## Ruled out
- [option] — [why not]
## Open questions / waiting on
- [what's blocked, or a choice you still need to make]
## Done this session
- [what changed today, in plain language]
## Next actions
1. [the single most important next step, spelled out]
2. [then this]
3. [then this]
## How to use this doc
- **Starting:** open a new thread, paste this in, say "Read this and pick
up where we left off."
- **Ending:** say "wrap." That one habit is what makes any thread resumable.
- **This doc holds context only.** It doesn't hold your work product. That
lives wherever it lives.
**Last updated:** [date] — [what was happening at that moment]
"Status now" is a paragraph, not bullets. Three bullets can't brief someone who wasn't there. Write it like you're catching up a colleague in the hallway.
"Ruled out" is the one people delete. It looks like history. It's the opposite. It's the only section that prevents a conversation you've already had.
Setup
Ask Chief to create a status doc from your thread, using the template.
Tell it what format: Google Doc, Word, Notes app, whatever you already use.
Make sure the status doc gets into your Chief Vault.
New thread? Paste it in at the top. The new thread walks in briefed.
You do not need a Project for this. You need a doc and a habit.
Now you can start any thread from where you left off.
Pitfall: the status doc that lies
A status doc nobody updates is worse than none. You'll trust it.
What to do: That's why wrap exists. The habit is the system. The doc is just where it writes.
The progression
Keeping status current
Three ways to close the loop. They differ in how much of it your hands have to do.
The doc only works if it's true.
So somebody has to update it before you stop.
Right now that somebody is you. It doesn't have to stay that way.
Three rungs. Same instruction every time. Less of your hands at each one.
1 · Beginner
Manual: you paste it back
The command:"Update the status doc before we stop."
That's the whole thing. Six words.
The doc's own header tells Chief what to do next. You just pull the trigger.
Chief rewrites it and hands you the text.
You paste it into your doc. Ten seconds.
Needs: nothing. No connector. No setup. Works today.
Costs: you paste it in at the start, you paste it out at the end.
The catch: it only happens if you remember. That's the whole risk.
2 · Intermediate
Versioned in your Chief Vault, through a connector
Connect Google Drive or OneDrive. Point Chief at your Chief Vault.
Now it reads the status doc itself. No paste-in.
At the end, it writes the update back as a new file, dated.
Tradeoffs
A connector doesn't edit your doc inline. It can't.
It can create new files. It cannot change one that already exists.
(Tested against Google Drive, July 2026. Same behavior on OneDrive.)
So every update lands as a new dated doc, sitting next to the old one.
Which means:
Accumulated backlog. You'll have a stack of STATUS – [project] – 2026-07-16 files. Not a problem, but you'll have to clear them out yourself at some point. Connectors can't delete.
Chief has to always read the most recent. You have to tell it, in thread, to pull the latest version. Until you build the skill. Then it's handled.
A stack of dated status docs isn't a mess. One undated doc you can't trust is.
Needs: a connector, pointed at your Chief Vault.
Costs: occasional cleanup.
You get back: both pastes. Gone.
3 · Pro
Automatic, via Cowork
Your Chief Vault isn't reached through an API here. It's a folder, on your machine.
Cowork works in that folder directly.
It reads the doc. It rewrites the doc. Same file.
No paste. No versions. No cleanup. No stack to sort through.
Every other rung ends with your hands. This is the one where the loop closes without you.
Needs: Cowork, with access to your Chief Vault folder. You can keep that folder in the cloud. Cowork works on a synced copy on your machine.
Costs: threads aren't reachable from the web or mobile right now. Chat vs. Cowork →
You gain: documentation done for you, on command. Chief creates, files and organizes all of it.
Reads your doc
Updates your doc
Your hands
Beginner
You paste it in
Hands you text
Paste in, paste out
Intermediate
Itself
New dated doc
Cleanup, sometimes
Pro
Itself
Same file, in place
None
Start at Beginner today. You can climb whenever you want. The doc doesn't change.
The move
Turn the command into a skill
You keep typing the same instruction. Write it down once, and one word runs it.
Look at what you're actually doing:
Every session ends the same way. You type "update the status doc before we stop."
On Intermediate you type more: read the most recent one, save the new one dated.
Same words. Every session. Forever.
Anything you type that often is something you should have written down.
That's a skill:
A skill is written-down instructions for a task you repeat.
You write it once. After that, one word runs the whole thing.
The word we'll use is wrap.
Type it, and everything you've been typing by hand happens.
Why not just say "summarize this"?
Because the instruction has to be precise, and you won't be precise at 6pm on a Thursday.
Most people type "summarize this thread" and paste the result into the next one.
What comes back is a recap of the conversation. What got discussed.
That's a transcript with fewer words. It's the noise, compressed.
Picture the status update from a project manager who doesn't get it.
"Today we discussed pricing. We talked through several models and considered the competitive landscape. We also touched on the launch timeline."
You now know nothing you didn't know this morning. What did we land on? What's still open? What do you need from me?
The good one writes four lines. "Pricing is $2,400, flat. Killed the tiers, too hard to explain. Launch date still open, waiting on legal. Need thirty minutes Thursday."
What you actually need is shorter, and different:
What did we decide? Not what did we discuss.
What's still open?
What's the next move?
What did I rule out, and why?
That last one is the one people lose. It's also the one you'll waste an hour re-litigating.
That's not a summary. It's a handoff. It's what you'd tell your chief of staff on the way out the door.
So here's the case for writing it down:
You could type those four questions every session. You won't.
The good version takes precision. Precision is what you have least of when you're done for the day.
A skill holds the precision for you.
A skill is how you stop depending on your own discipline.
Part B · Build it
The build
Build wrap
Fifteen minutes. Then you never type the instruction again.
What you're about to have:
You type wrap at the end of a session.
It pulls out what changed. Decisions, not discussion.
It rewrites status and delivers it the way your setup allows.
You skim it, and close the thread. Nothing was in there.
Where the instructions live is the only choice here. Same text every time. It maps to the three rungs above.
Rung
Where wrap lives
What wrap does with the doc
Beginner
Your Project's instructions
Hands you the text. You paste it back.
Intermediate
Uploaded to your account
Saves a new dated doc in your Chief Vault.
Pro
A file in your Chief Vault
Rewrites the file in place.
The instructions
---
name: Wrap
description: Close out a work session and rewrite the status doc. Use when the user says wrap, close out, end session, or done for now.
---
# Wrap
Close out this work session so the next one starts where this one ended.
## Steps
1. Find the current Status. It was probably pasted in near the top of
this thread. If it lives in a connected Chief Vault, find every file
whose name starts with "STATUS" for this project and read only the
MOST RECENT one. Ignore the older ones. If you can't find it, say so
and ask.
2. Look back over this thread and pull out only what changed:
- Decisions made. Not topics discussed. Decisions.
- Things ruled out, and the reason why.
- Questions still open.
- The single next move.
3. Rewrite Status. Do not append. Rewrite it so it reads as
"here is where we are now," not "here is what happened."
4. Keep it under one page. Cut anything that is settled and no longer
shapes the next move.
5. Deliver it the way this setup allows:
- No connector: output the whole rewritten Status in one block I can copy.
- Connected Chief Vault: save it as a NEW file named
"STATUS — [project] — [today's date]". Do not try to edit the old
one, you can't. Do not delete the old one, you can't. Leave it.
- Cowork: rewrite the Status file in place. Same file.
## Rules
- Decisions, not discussion. "We talked about pricing" is worthless.
"Pricing is $2,400, flat, no tiers" is the whole point.
- If something was ruled out, say why. Future me will ask.
- If two things in this thread contradict each other, do not pick one.
Flag both and ask.
- Never delete an open question just because nobody mentioned it again.
Read the description line twice. It's not a label. It's the trigger.
It's how Chief decides to fire this when you type "wrap."
So it has to name the words you'll actually say.
The line that solves the version stack
Look at Step 1. "Read only the MOST RECENT one. Ignore the older ones."
On Intermediate, that was your job. You had to remember, every session, to tell Chief which doc was real. Forget once and it briefs you off a stale doc without either of you noticing.
Now it's in the skill. You don't remember it. It does.
Step 5 does the same thing. It saves the new doc dated, and it knows not to try to edit or delete the old one, because it can't.
Every rule you were carrying is now in the file.
The other half: resume
wrap closes a session. Something has to open one.
On Beginner that's easy. You paste the doc in. You're the one choosing.
On Intermediate it's the whole ballgame. You have a stack of dated docs, and Chief has no idea which one is real.
Above, that was something you'd have to remember. This is you not having to.
---
name: Resume
description: Pick up work where the last session ended by reading the status doc. Use when the user says resume, pick up where we left off, where were we, or catch me up.
---
# Resume
Start this session from where the last one ended.
## Steps
1. Find the status doc for this project.
- Pasted or attached in this thread? Use it.
- In a connected Chief Vault? Search for files named
"STATUS — [project]". There will be several, dated. Read ONLY the
most recent. Ignore the rest.
- A file in a Cowork folder? Read it.
- Can't find one? Say so and stop. Do not guess.
2. Read all of it. The basics, status now, decisions, ruled out,
open questions, next actions.
3. Tell me in under 100 words:
- Where we are.
- What's next. The top item from Next actions.
- Anything in Open questions that's waiting on me.
4. Name the file you read and its date. If it's more than a week old,
say so out loud.
5. Stop. Do not start work until I tell you what we're doing.
## Rules
- Never invent state. If the doc doesn't say it, you don't know it.
- Nothing under "Ruled out" gets reopened. That's settled.
- If the doc contradicts itself, flag it. Do not pick a side.
- Reading an old version poisons everything after it. If you're not
certain which is most recent, ask.
"Name the file you read and its date. If it's more than a week old, say so out loud."
This is the line that catches the failure you'd never catch yourself. Chief reads a stale doc, briefs you confidently off it, and you have no reason to doubt it. Making it say the date out loud turns an invisible failure into an obvious one.
Two skills, not one:
resume opens. wrap closes. Two files, two uploads.
Anthropic's own guidance: keep skills focused, one workflow each. Focused skills compose better than one that does everything.
Say resume. Do the work. Say wrap. That's the whole system.
Two words now hold the thing you used to hold in your head.
Where to put them
Beginner: paste them into a Project
Least setup, if you already have a Project.
›
Open your Project → Instructions → paste both blocks above. Done.
You get: wrap and resume fire in any thread inside that Project.
It costs: they only live in that Project.
Build a second Project? Paste them again.
Change the wording? Change it in both.
They don't travel.
Use this if you already work in a Project and want the habit running in five minutes. Upgrading later is a copy and a paste. The text is identical.
Don't have a Project? You don't need one. Use Intermediate.
Intermediate: upload them as real skills
The default. Fifteen minutes once. Then they're everywhere, forever.
›
Uploaded skills live in your account, not in a Project.
Every thread. Every Project. Every device.
You trained the habit once. It doesn't leave when you change desks.
Works on Free, Pro, Max, Team, and Enterprise. (Checked July 2026.)
Step 00 · Check this first
Settings → Capabilities → turn on code execution.
Skills don't run without it. This is where people get stuck.
Thirty seconds now saves a confusing ten minutes later.
Step 01 · Download both
Hit ↓ Download wrap.zip and ↓ Download resume.zip above.
Both are already packaged. Folder, SKILL.md, correct structure.
No folder to build. Nothing to zip.
Step 02 · Upload them
Go to Customize → Skills.
Upload both ZIPs. Toggle both on.
Step 03 · Test them before you trust them
Open a new chat. Paste in a status doc. Type resume. Then type wrap.
Watch what each one does.
Nothing fired? It's one of two things. Code execution is off (Step 00), or the description doesn't include the word you typed.
Fix the description. Re-upload.
Step 04 · Use them for real
Next work session, type wrap at the end.
Do it once and you'll feel the difference on the way back in.
Want to change one first? Download the raw SKILL.md, edit it, then paste it into a new chat and say: "Package this as a ZIP I can upload in Customize > Skills. One folder called wrap at the root, with SKILL.md inside." Worth doing once, just to see that Chief can package its own skills. That's the whole trick behind Phase 3.
You just built a skill. That's the whole mechanism. Phase 3 is this, with bigger instructions.
Pro: keep them in your Chief Vault
For when your files and your Chief are in the same place.
›
In Cowork or Claude Code, a skill is a file in your folder.
It sits next to the work it's about.
You get:
No paste-back. It rewrites your status doc on disk. You never touch it.
You edit the skill like any file.
It's version-controlled. See what it looked like in March. Roll back a change that made it worse.
It lives next to your status doc and your work. Not in a settings menu.
It costs:
You need a folder Chief can reach.
You need to be comfortable with files.
Different surface, different tradeoffs.
Use this if you already work out of a real folder. If that sentence meant nothing to you, use Intermediate. You lose nothing. Same file. It moves when you're ready.