aranculleton/last-job-search / .claude/skills/app
app
VerifiedThe 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.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 8.9 KB |
| chat.md | markdown | 11.1 KB |
| jobs.md | markdown | 12.7 KB |
| wake.md | markdown | 15.5 KB |
| work.md | markdown | 13.9 KB |
work.md
View on GitHub# What each kind of work runs
Step 4 of a wake (`.claude/skills/app/wake.md`): `wake` prints the item's own row under
`next:` (`do`); this table is where every row is kept (`app.py work_row` reads it).
## 4. Do the work with the app's own commands
The item's `kind` and `args` say what (`answers` holds what the person already said on the
page, so never ask it again):
| kind | run |
|---|---|
| search | `run_round.py --show <args.size>` (10 when it is not given; 0 is every one that fits, up to 60) `--work <its id>` (it names the item in the round's log, so `app.py done` waits for this round's own shortlist), then the shortlist (the job-scraper skill); `args.note` is what the person typed about it, followed like any instruction of theirs: a note naming employers ("only these: A, B, C", "search these 20 employers") is `--employers "A, B, C"`, which searches only them, keeps a place for each and says which had no open roles. A top-up (a size of 15 or fewer, or "find N more"): add `--pages 1 --expand`, one page of each site first, wider only when fewer than the size pass every rule (a full read of every site for ten roles took 23 minutes, 2026-11-03). What the round rules out is off Jobs in the same step, each with its reason (`left out: N ...`): never cleared by hand. `args.draft` (the page's "Draft every one as it is found"): one job, the search drafting each job that passes as it is found, in its own chat, as its steps say (`app.py search-drafts`) |
| draft, resume_for_contact | a draft that stops because the role is not one they can take (where it is open, eligibility, a hard cut) finishes with `app.py done --work <its id> --chat <the claim> --left-out "<why, plain>"`, which takes the job off Jobs in the same step, ruled out with that reason, so the Brief and Jobs stop counting it (one stopped for Figma stayed in "10 jobs to look at", 2026-10-30); one run for the item and each in `with` (drafts queued together are one batch: `stage_picks.py stage` takes them all), by the drafting path in RUNBOOK.md step 2 (`stage_picks.py stage`, `consent` from the item's `answers`, or from `args.answers` (each question with the person's answer) when the page queued it, and only what they answered: a skill question nobody answered is already on their page, once for every draft, and the draft goes on without the skill, waiting on it, never a no and never a `--question` of its own; the workflow, both audits, `assemble`, RUNBOOK step 3), and its PDFs reach the page's file store by themselves: its `app.py done` queues one `files` item, for every draft whose files the page lacks and every resume made for a contact (`resfor-<contact>`, so their card's Get it downloads at once), for the chat that answers the page (a job's own chat cannot upload: Artifact is not among its tools), so no card asks the person to "Get my files ready" and nobody uploads by hand. `resume_for_contact`: `stage_picks.py --for-contact <args.contact>` for `args.job`, or, when `job` is null, `stage_picks.py general <dir> --for-contact <args.contact>`: one made for them, kept in their folder and shown on their card, never in place of the person's own; `args.note` is what they typed. `args.resume_only` (the page's "Draft the resume only") stages with `--resume-only`: the resume without a letter, and nothing names a letter |
| evaluate | /apply Step 1 on `args.url` or `args.text`, then `added_jobs.py add <row.json>`; with `applied_on`, `confirm.py applied --new`; with `contact` (who sent it), that person is the job's referral route: `network/state.py set <contact> --next-action "apply via <first name>'s referral" --note "sent <role> at <employer>"`, never by hand, and `result.summary` says who it is linked to; with `draft: true`, once it is scored queue its `draft` work as tapping Draft does (`app_actions.py` `_job_draft`); with `from_name` (someone not in the contact book), add "sent by <name>" to the role's notes |
| general_resume | `stage_picks.py general` (the profile's own summary; one Claude writes goes with `--summary-file` and its claim map, `--claims-file`, and one the grounding audit questions is never made). Its pencil's changes are `tweak` work like any resume's |
| prep | `/interview` for `args.interview`; with `args.contact`, `network/prep.py "<contact>"`; `args.note` is what they typed (a format it names, "a timed test" or "personal experience then live coding", is the `--format` of its `interview_pack.py live`). The page's "Not this kind of interview?" sheet sends `args.format` (what the person tapped the round is), used as the `--format` of its `interview_pack.py live`, which keeps it on the round's record. Preps queued together are claimed together (`with` one another) and are one run: the stories read once, each employer's research and words shared by its rounds, every live prep's words written in the same pass, each interview finished with its own `app.py done` |
| network | `/network` (`args.count`: how many people this run finds and drafts a note for, a target, not a cap: when the employers searched so far run out, it widens to the next ones and reads on until that many are drafted, and finishes with `app.py done ... --drafted <n>`, which refuses a run short of the number; only when no good people are left within the person's rules does it finish short, `--drafted <n> --short "<why, plain>" --summary "<n> of <count>: <why>."`, kept as part-done; 5 when not given; `args.note`: what the person typed about this run, an employer, a team or a kind of person, followed like any instruction of theirs; `args.company`: one employer's own Find people; `args.rewrite`: that contact's waiting note, rewritten on the profile just read; `args.read_first`, sent `to: computer` by itself where their computer is ready: read each of `args.contacts` in this computer's browser first, `reading.py read <contact> - --source browser`, then rewrite each note as `args.rewrite`, or write their first note from the reading where none was saved (with the computer reading profiles, a people search saves none before the read: `reading.reads_first()`); `args.left_out` names who it left out and why, said in one line of the answer), the networking skill |
| reply | `/reply` (`args.received` names their logged message, and with none it is their latest one in the log; `args.want`, what they want to say back, in their words; `args.update`, news for a referrer; `args.kind: thank_you` a thank-you, `args.kind: referral_ask` with `args.job` (or `args.role` and `args.url`, the posting their hold waited for) the referral ask for that one role, `compose.referral_ask()`). No skill is loaded: `reply.py prepare` prints the guidance, the thread and the person's own rules, and `reply.py finish` holds the checks |
| follow_up | follow-ups queued together are claimed together (`with` one another), and one run does them all: `python3 tools/app.py follow-ups "$D" --chat <your chat id>` drafts each in code, gated, keeps it where Messages shows it and finishes them in one batch. What code could not write comes back in one context block: write those in one go and pass them back with `--written -`. No skill is loaded and nothing is drafted one by one. One with `args.application` (or `args.interview`) is an application's or an interview's follow-up: `/outcome` Step 2b, never the networking skill |
| own_profile | `network/own_profile.py check` |
| profile | the change in `args` (`part`: job, skills, education, certificates or fill; `change`: add, edit or remove), made the way `/setup` writes that part: `01-candidate-profile.md` first, then `roles.py`, `bullets.py`, `skills.py` and the summary in `profile/CLAUDE.md` to match. Only what the person gave goes in, in their words and with their numbers; a job added gets its resume lines written from `args.text`, and anything unclear is asked in the work's thread, never guessed. A removal takes it out everywhere. Then `stage_picks.py general` for a fresh resume; `result.summary` says what changed |
| brief | the brief's prompt; with `args.setup: true`, turning the brief on in this chat, not running it: `list_triggers` (every page), `python3 tools/routines.py brief --triggers <each page>`, and the calls it prints, which make the brief a chat of its own with the copy attached and bind the task there, never to this chat (automation/README.md, "For Claude") |
| research | by `args.topic`: `employers` with `args.employer` is one employer's own job board, `python3 tools/ats_boards.py --find "<employer>"`, recorded in `profile/boards.py` as `/setup` step 3 does; any other topic (`research~<topic>`: boards, market, documents, voice, employers) is that part of `/setup` step 3's research, recorded as it says. An employer's facts for a letter or an interview are the `employer-researcher` subagent's, never this |
| update | `sync_app.py --update`: the person asked, on the page. Then the page steps it prints, at once and unasked. Their setting (the line the check ends with) wins over any older instruction in this chat. With `args.refresh` it is the page's Refresh instead: `sync_app.py --on "<your model>"` with no flag (it takes an update only where updates come by themselves), the page steps it prints, then step 5, whose `app.py view` writes today's data; `result.summary` "Your page is up to date." |
| talk | read the thread's messages and their pictures (`.claude/skills/app/chat.md`); do what it asks; answer in the thread. `args.about` (`kind`: person, message, job, application or interview; `id`: that card's item; `label`) is a question asked under that card with its Something else, in the card's own thread, and the answer shows under that card, never in the Chat: answer about that one, looked up by the id, never by the name, in a few plain lines (a change it asks for, such as a draft rewritten or a record corrected, is made and then said in one line). `kind: place` is asked under a place rather than a card, by its `id`: `paste` a message someone sent (handled as a message pasted in any chat is, `.claude/skills/app/chat.md`), `interview` an interview to add (registered as /outcome does), `wrong` something on the page that looks wrong (the person's own "Something looks wrong"), `rules` tidying what they taught (`learned.py tidy --clashes`, each shown before anything goes), `chats` old chats to bring back, `held` a pill under Your rules, Held back for now (`python3 tools/holds.py lift "<args.about.ref>" --said "<its words>"` lifts that one hold by its id, keeping their words; the words alone can name two holds; where it says what to ask or run first, do that) |
| files | upload each file (Artifact publish, `asset: true`; `args.paths` names them, for every application in `args.applications`), then `app.py files-saved <path> <asset id>` for each |
| tweak | `tweak.py apply "$D" --work <its id>` (the id as printed, or its file in `$D/work`), one `--work` for it and each in `with`; queue its `then`, call its `tools`; `needs_model` lists the redraft steps. One that changes nothing (held, set aside, not possible, already as asked, or an answer carrying `outcome`: a message's words about every note waiting for a profile, put on the page's reading list instead) finishes with `app.py done ... --outcome held\|set_aside\|unchanged` and its summary, so its card says so at once (a message held takes `--until <YYYY-MM-DD>`, the day to look again, and the hold goes on their record); a written answer goes with `--reply-file -` and shows on its card |
| form_answers | the questions an application's form asks beyond the resume and the letter ("why us?", "why this role?", "a time you used X"), pasted on its card: `args.item` (the draft or the application), `args.slug` (its folder; else `python3 tools/form_answers.py folder --company "<args.company>" --role "<args.role>"`), `args.text` (their words). `learned.py brief documents` first. Each question is answered from `01-candidate-profile.md` and the folder's `job_posting.md`, in their voice, one paragraph, claiming nothing the grounding sources do not hold (a skill they hold is fine); an example they asked for that the profile does not hold is a plausible draft, written with `--draft` so the card marks it for them to confirm. Each goes in with `python3 tools/form_answers.py add --slug <slug> --question "<the form's words>" --answer "<answer>" [--note "<why, one line>"] [--draft]`, the same question again replacing its answer; never the resume or the letter. Words in `args.text` that ask to change the resume or the letter are that document's tweak, queued as the Tweak panel's own words are: `app.py ask <dump> --kind tweak --title "Edit <noun>: <company>, <role>" --args '{"v": 1, "target": {"id": "<args.item>", "output": "resume" or "letter", "company": "<args.company>"}, "changes": [], "text": "<their words>"}'`. A question that cannot be answered honestly (unclear, or a fact the profile lacks) is asked only then, as `needs` (`app.py done --question`). Finish with `app.py done <dump> --work <id> --summary "<n> answers ready to copy on its card" --answered "<each question as the form asked it>"` (one `--answered` a question), so the card says Done only once they are on it; step 5 (`app.py view`) puts them there |
| republish | the page's own code changed: `app.py page --out-dir <scratchpad>/page --url <url>` (with `whole: true`, the page's own "did not load fully" button, add `--whole`: every code file goes up again), then do exactly the steps it prints: from this copy's record of the last publish, only the publishes of the small files that changed since; only where it asks (no record, another page, or one older than the page's last publish), read the page, list its files and give that list, every line exactly as it came, to the same command (a list copied short or with one size for every file is refused), then the publishes, only the small files the page lacks (or holds wrong), each read whole first (the page itself once, before the first), and capabilities only where it says (refused: read the page again and publish once more), then `app.py published <url> --parts <scratchpad>/page`. Never ask first. With `already: true`, publish nothing: finish it done |
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |