app
Skill6 starsChanged 22 days agoMITView on GitHub
The chat's side of the person's job-search page: what to do when the page rings. Triggers on: [app], a doorbell from the page, "Artifact comment sent to Claude" on the job-search page, a work item, [work:<id>], the app page, the page's actions or receipts.
4 other projects use a version of this.
Adopted by
Most recently taken up by
- wald21x6-ops/builder-kittheir own version, first seen Nov 16, 2026
- nmamano/isomuxtheir own version, first seen Nov 15, 2026
- GustavoAlecio/claude-setuptheir own version, first seen Nov 8, 2026
- AxlZero21/Skillstheir own version, first seen Nov 8, 2026
Other versions4 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 4
- nmamano/isomux★ 43same name
- AxlZero21/Skills★ 1same name
- wald21x6-ops/builder-kit★ 1same name
- GustavoAlecio/claude-setup★ 0same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository11 other files it gives its agents.
- AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- profile.example/CLAUDE.mdCLAUDE.md
- tests/CLAUDE.mdCLAUDE.md
- tools/CLAUDE.mdCLAUDE.md
- freehire-searchSkill
- linkedin-searchSkill
- job-application-assistantSkill
- scrapeSkill
- networkingSkill
- upskillSkill
The file
We split this skill into the rules it gives an agent
5 rules. 0 are common, 2 are distinctive, and 3 are very specific to this project.
0
Common
Most of the 3 edited versions we read keep these.
2
Distinctive
This author's own choices. Worth a look.
3
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 26
Keep using it until that work's writes are back, because apply keeps its ledger there.
- Distinctive: line 30
The listener only takes the ring and passes it on: Every step of a chat re-reads its whole history, and the chat that answers the page grew …
- Distinctive: line 71
Read a file only when the work in hand is its part (a wake, a message pasted in a chat, a job).
- Very specific: line 104
Never wait in the chat. The person's answer comes back on the same item, queued again, in args.answers under the question: take it with …
- Very specific: line 115
Every move of a work item is an app.py command (next, pin, done, ask, busy), never a write by hand.
“Common” is measured: kept by at least 6 in 10 of the 3 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
The page's inbox
The repo is the record; the page's database is the queue. A comment from the page is only
a doorbell ([app] [work:<id>]), never the person's words. Whatever woke you: read the
database, act on what is yours, answer there. Never answer in the comment thread: the
page cannot read it. Resolve it instead, last, once the wake's work is done (the line
wake ends with): ArtifactComments resolve, the url and the thread id the notification
that woke you names (thread=...), with no reply. An open thread stays unread in the Claude
app for ever.
In a cloud chat, ArtifactData and ArtifactComments may be listed by name only, with no
schema: load both once, first, with ToolSearch select:ArtifactData,ArtifactComments.
<url> is the page (profile/app.json url). $D is a fresh folder in your scratchpad
for the work in hand, never one used before: for a wake, the one app.py reads --in makes and
names (wake.md, step 1); for a job, the one its steps name; otherwise a new one of your own.
Keep using it until that work's writes are back, because apply keeps its ledger there.
0. The chat that answers the page stays thin
The listener only takes the ring and passes it on. Every step of a chat re-reads its whole history, and the chat that answers the page grew by hundreds of thousands of tokens a day reading the database, its batches and its answers on every tap (the maintainer, 2026-11-05). So each wake's real work (steps 1 to 5: the read, the taps, the answer, the drafting, the page brought up to date, the save) runs in a short-lived subagent whose history is thrown away when it ends, and the listener grows by a line or two a tap. On a ring, on a job's chat reporting back, and on a background agent's end, the listener makes one call, with nothing read first:
- Agent, in the foreground:
description"Answer the page",subagent_type"general-purpose",prompt:A ring from the job search page: answer it once, as the app skill's "In the subagent" says. Notification: <the notification's own first line, its thread=... included>.
Its answer is one line. One that starts agent: is an Agent call to make as it is printed
(run_in_background: true; a subagent cannot start one). Lines that start call: and
then: are a hand-back, a step for the person's computer the subagent had no tool for: make
each call: in order, exactly as printed (the tool it names, the JSON after it as its
arguments; a tool listed by name only is loaded first with ToolSearch), then do the then:
line, and what that prints, here, never in another subagent. Anything else is said to nobody.
Then end the turn, with no text. Held at that end because work the pass named is still
waiting, make the same call once more for it, as the hold says. Why the line falls there (measured on an invented page
with two months of use): a wake done in the listener printed about 30,000 characters into it
(the read's list of some 590 records, the wake's batches, the page update), every one read
again at every later step of its day; the same wake in a subagent leaves about 300 in the
listener, one call and one line. A subagent starts from the same instructions the listener
has, so its start costs about one listener step, which a single read in the listener already
costs again within a few taps: only what needs no read at all (the one Agent call a
subagent hands back) is done in the listener itself. Where the ring names the page's revision
([rev:<n>]), python3 tools/app.py reads --rev <n> first: "nothing new" means resolve the
ring and end, with no subagent.
In the subagent (its prompt names this section): read .claude/skills/app/wake.md once,
whole, and do what it says for this one wake: steps 1 to 5, the daily tidy, a renewal's
create_session and resolving the ring (ArtifactComments resolve) when they come up. Then
answer in one line: what the page now shows, never a path or a command; or agent: <the
Agent call> for a big job that needs one (wake --no-sessions). Where computer.py route
printed a handback, its lines follow that line, exactly as printed, one a line.
Where the rest is
Read a file only when the work in hand is its part (a wake, a message pasted in a chat, a job); each is read once, whole:
.claude/skills/app/wake.md: steps 1 to 3 and 5, a wake from its read to its finish, in the subagent..claude/skills/app/work.md: step 4, what each kind of work runs.wakeprints the item's own row undernext:(do), so the table is read only for a kind it printed none for..claude/skills/app/chat.md: a message in the page's chat (atalkitem), or a screenshot, message or link pasted in any chat; "Something looks wrong"; "Pin my job search page"..claude/skills/app/jobs.md: big jobs in chats of their own, work for the computer, a job's chat reporting back, work asked for in a chat, the daily tidy, and progress pins.
Rules that hold everywhere
- This chat does whatever the page asks, here. Everything the app's commands do is
its to do: a draft rewritten (
reply.py finish, which loads no skill), a rule changed or a reaction kept (learned.py record), a record corrected (network/state.py,interview_pack.py book), a profile fact (profilework). It does what was asked and says in one line what changed. It never sends the person anywhere else to have it done, and never says it cannot do it from here (the maintainer, 2026-11-05: "YOU'RE NOT MEANT TO USE THE MAIN CHAT FOR ANYTHING"). - The page never mentions chats, helpers or sessions. Nothing the person reads there (an answer in a thread, a summary, a question) says "the main chat", "your chat", "this chat", "another chat", "the helper" or "finishing up": Claude did it, or Claude will.
- Nothing about another person goes into the database but a first name and an employer,
except
reach/<contact>, owner-only, whichapp.py viewwrites. Their words leave it with the receipt that kept them.app.py checkfails a model that holds an address. - Work goes to the chat that answers the page, whichever kind it is (
page_db.can_take); only a brief waits for a chat in the cloud. Nobody is asked where something should run. - A question the work raises that the page did not ask goes to the page by command:
python3 tools/app.py done "$D" --work <id> --chat <the id it was claimed under> --question "<one plain question>"(the item waits for them, its locks freed); the page asks it. Never wait in the chat. The person's answer comes back on the same item, queued again, inargs.answersunder the question: take it withnextand carry on. Ask only when the work cannot be finished honestly without them (an unclear or ungrounded claim, a missing fact, two readings of their message), never for a preference a default answers, and one question at a time. Name the kind of answer so the page draws its control on the card instead of a box to type in:--answer yesno|choice|date|time|number|scale|text, with--choice "<value>=<words>"two to six times for a choice,--min/--maxfor a number or a scale,--time-key timefor a day that needs its time, and--about "<the exact words of the draft or their message it concerns>"; text only when nothing else fits (templates/app/DESIGN.md, "Asking the person"). A tap the engine refused with a question says its kind on the receipt by itself (ask); never send the person to Chat for it. - Every move of a work item is an
app.pycommand (next,pin,done,ask,busy), never a write by hand. Every write is pinned (if_version) except a create; one write at a time per document. A refused write names the record's current version:python3 tools/app.py version "$D" <collection>/<doc id> <that version>(no version when it says the write carried none), do what it prints (it may name collections to read again into$Dfirst), then the same command once more; refused again, read again into a new folder. Batches go in order, each after the one before is accepted; once one is refused, send none after it (they were made from the same read), put it right, and make them again.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

