Skip to content

rse/ase / plugin/skills/ase-task-estimate

ase-task-estimate

Verified

Estimate the effort of the current, given, or all unestimated task plans as T-shirt sizes (XS, S, M, L, XL) of expected human time, and store it in the "Effort:" frontmatter key, or calibrate the estimation against the actual human time of the finished tasks. Use when the user wants to "estimate", "size", or "gauge the effort" of a "task" or "plan", or to "calibrate" the effort estimation.

@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md @${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md @${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md

$ARGUMENTS

@${CLAUDE_SKILL_DIR}/../../meta/ase-format-task.md

Procedure

Derive the scores of the plan (the body only, never the frontmatter or backmatter), skipping every bullet-point in the inert checkbox states [-] and [>] entirely, while all other checkbox states (including [x], as the effort covers the entire lifecycle of the task) count alike. A bullet-point without a type (like in a legacy plan) counts with the types following from its section: DOM or IFC for a context or specification section (but nothing for a pure rationale like a why), ARC or IMP for a changes or design section, and REG or CON for a verification section. Do not output anything.

  1. Attention score: set to the sum of the weights of all counted bullet-points, with the weights DOM 5.0, IFC 4.0, ARC 3.0, IMP 1.0, REG 0.5, and CON 1.0, each multiplied by the item count of the bullet-point: the number of distinct requirements, behaviors, or changes it states (at least 1), like one per independent statement or per enumerated element, so a dense bullet-point stating ten key bindings counts ten times, while a bullet-point stating a single fact counts once. Set to times .

  2. Volume score: predict the code impact of the counted ARC and IMP bullet-points strictly read-only from the plan and the code base (never change, stage, or commit anything), disregarding any already existing change set of the task (its uncommitted changes, its branch, or its change set attachment): never measure the volume from such a change set, so estimations before and after the implementation stay comparable. Set to the number of files they touch (or create) -- the files named by the bullet-points plus the files following from them, like call sites, documentation, manual pages, and generated catalogs -- and to the estimated number of changed lines, sizing new files after comparable existing ones and changes after the code they touch, and to the part of in newly created files. Set to times plus plus twice times , so a newly written line weighs three times a changed one. As a plan describes the straightforward path only, while the edge cases, the error handling, and the polishing of the realization regularly multiply its size, already covers this growth, hence do not inflate the predicted lines themselves.

  3. Base size: set to plus , and set to the smallest size of XS, S, M, and L whose upper band bound in is greater than or equal to , or to XL if exceeds all bounds.

  1. Determine Operation:

    1. Set to the whitespace-separated tokens of , each with a trailing : removed. Inherit the always existing , , , and from the current context. Do not output anything.

    2. Validate the arguments and options:

      • If a token of does not match the regexp ^[a-zA-Z0-9#][a-zA-Z0-9#_-]*$, only output the following and then immediately STOP processing the entire current skill:

      • If is true and is not empty, only output the following and then immediately STOP processing the entire current skill:

      • If is true and is not empty or any of , , and is true, only output the following and then immediately STOP processing the entire current skill:

      • If is true and is not true, only output the following and then immediately STOP processing the entire current skill:

    3. Determine the estimation configuration: for each of the keys project.task.effort.scale, project.task.effort.factor, project.task.effort.file, project.task.effort.line, and project.task.effort.iteration, call the ase_config_get(key: "<key/>", scope: "project") tool of the ase MCP server and JSON-decode its text output field. Set to the four comma-separated upper band bounds of XS to L (default: 15,60,240,960), to the human minutes per attention-score point (default: 1), to the human review minutes per touched file (default: 1), to the human minutes per predicted changed line (default: 0.025), and to the iteration multiplier of interactive user interfaces (default: 2.5), each falling back to its default if empty or malformed. Do not output anything.

    4. Determine the finished states and the successful finished state of the task lifecycle model : CLOSED and CANCELLED resp. CLOSED for solo (or absent), IMPLEMENTED and CANCELLED resp. IMPLEMENTED for team, and INTEGRATED and CANCELLED resp. INTEGRATED for enterprise. Do not output anything.

  2. Estimate Task Plans:

    1. Determine the tasks to estimate:

      • If is true: call the ase_task_list(verbose: true) tool of the ase MCP server and set to the id of every entry of its tasks array whose status is not in and -- unless is true -- whose effort is empty.

      • Else, if is not empty: set .

      • Else: set .

    2. Set to the analogues for cross-checking: call the ase_task_list(verbose: true) tool of the ase MCP server (or reuse its result of sub-step 1), take every entry whose status is and whose effort is not empty, and pick up to five of them whose title is most similar to the tasks of . For each picked one, call the ase_task_attachment(id: "<id/>", type: "application/yaml; kind=\"usage\"") tool of the ase MCP server, and keep it only if it carries a usage attachment (a WARNING: response means none), whose YAML payload time: { ai, hr, real } carries a hr of at least 5 minutes, together with its effort size and the size whose band covers its time.hr (its actual size). Do not output anything.

    3. For each task id of , perform the following per-task workflow, where a failing task never stops the processing of the remaining tasks:

      1. Load: call the ase_task_load(id: "<id/>", tag: true) tool of the ase MCP server -- with the variant argument defaulting to source and the attachments argument defaulting to elided -- and set to its text output field without the trailing <task-plan-tag> delimiter line, and to the content of that line.

        • If is empty, set skipped: no plan and continue with sub-step 5.

        • If the Group: frontmatter key of equals its Id: key (an explicit epic), set skipped: epic and continue with sub-step 5.

        • If carries an Effort: frontmatter key (which the task store only delivers if it is valid) and is not true, set to its size and skipped: already estimated and continue with sub-step 5.

      2. Score: derive the scores of :

      3. Adjust:

        • Risk surcharge: determine which of the risks dependency (a new or upgraded third-party dependency or external service), ambiguity (bullet-points in state [?] or vague, underspecified wording), untested (changed code without an automated test procedure covering it), concurrency (parallelism, locking, or race conditions), security (authentication, authorization, secrets, or untrusted input), and persistence (data formats, migrations, or stored state) apply to . There is no architecture risk, as the ARC weight already covers it, and a risk applying to virtually every task of the project (like untested in a project without any automated test procedure) does not count, as the calibrated rates already absorb it. Set to 20 percent per applying risk, but at most 40 percent in total, and raise by percent.

        • Iteration multiplier: if the main deliverable of is an interactive or visual user interface (like a terminal UI, a web UI, a layout, or a rendering with key or pointer handling) which is built or substantially reworked, set to , as such work regularly needs many rounds of post-adjustment which no plan foresees; else set to 1. A mere display detail of an existing interface (like an additional badge or column) does not count. Multiply by -- outside the cap of the risk surcharge -- and re-determine from the resulting like the base size.

        • Plausibility: if the code base already contains a comparable realization of the planned functionality (but never the change set of the task itself, see the volume score), set to its size in lines and consider the prediction implausible if and differ by a factor of at least 2. A reference never changes itself.

        • Confidence: set to HIGH. Lower it by one level (HIGH to MEDIUM to LOW) if the ambiguity risk applies, by one level if the prediction is implausible, and by one level if is empty or if the analogues of comparable scope disagree with (their actual size differs from by at least one band), and by two levels if they disagree by at least two bands, but never below LOW. The analogues never change itself.

        • Drivers: set to the 2-4 main drivers of the estimation (like the dominant bullet-point types, the code volume, the applying risks, the iteration multiplier, an implausible prediction, or the analogues), each as an ultra brief phrase.

      4. Persist: set estimated (dry-run, not stored). Set the Effort: frontmatter key of to just -- without any content hash, as the task store stamps it on save -- replacing an already present Effort: key, or creating it at its position in the key order of the plan (directly after Kind: resp. before Tags:). Change nothing else of : especially, do not refresh the Modified: key (an effort is no body change), do not change the Status: key, and pass the entire backmatter through verbatim (with its elided Data markers). Call the ase_task_save(id: "<id/>", text: "<plan/>", base: "<tag/>") tool of the ase MCP server, so a change of the plan made meanwhile by anybody else is merged, and the save is refused if that change touched the same parts or the body. This ase_task_save MCP tool call is the only permitted way to persist the plan -- NEVER write the plan file via Write/Edit or by executing a shell command.

        • On success, set effort estimated.

        • If the save is refused because the plan was changed meanwhile, reload and re-estimate the task by restarting the per-task workflow at sub-step 1, at most three times in total, and afterwards set failed: plan changed concurrently.

        • On any other error , set failed: .

      5. Report: only output the following :

    4. Finally, give the closing hint by expanding the following (which, depending on the configured , may expand into nothing and hence emit no output at all), and then STOP processing the entire current skill:

  3. Calibrate Estimation:

    1. Call the ase_task_list(verbose: true) tool of the ase MCP server and take every entry whose status is (a task which reached its intended outcome, unlike a cancelled one) and whose effort is not empty. For each of them, call the ase_task_attachment(id: "<id/>", type: "application/yaml; kind=\"usage\"") tool of the ase MCP server and keep the task as a sample only if it carries a usage attachment (a WARNING: response means none), whose YAML payload time: { ai, hr, real } carries a hr (the time.hr) of at least 5 minutes, as agent-driven tasks book little human time. For each sample, set its actual size to the size whose band in covers its time.hr. Do not output anything.

      Then re-score every sample with the current rates, as its stored effort was estimated with the rates in effect at that time (which nothing records), so calibrating against it would apply an already applied correction again on every repeated calibration: call the ase_task_load(id: "<id/>") tool of the ase MCP server, set to its text output field, and -- skipping the sample if is empty or starts with ERROR: or WARNING: -- derive the scores of :

      Here, predict the volume as of before the realization of the task, i.e. never measure it from the realized code in the code base. Then apply the risk surcharge and the iteration multiplier of sub-step 2.3.3 (but not its plausibility, confidence, and drivers), and set the re-scored minutes of the sample to the resulting and its estimated size to the resulting . Do not output anything.

    2. Determine the calibration figures:

      • Band matrix: the number of samples per pair of estimated size (rows XS to XL) and actual size (columns XS to XL).

      • Hit rate: the percentage of samples whose estimated size equals their actual size.

      • Bias: the mean of the band differences (estimated minus actual, in bands), where a positive value means overestimation and a negative one underestimation.

      • Correction: is the median of time.hr divided by the re-scored minutes over all samples.

      • Fitted rates: , , and are , , resp. , each multiplied by and rounded to two significant digits, as the best-fitting rates, which scale the entire estimation (attention and volume) proportionally. As the samples are re-scored with the current rates, a repeated calibration right after saving the fitted rates yields a of about 1 and hence converges instead of compounding.

      • Suggested scale: the bounds of , each multiplied by , rounded to integers -- an alternative to the fitted rates and a suggestion only, which is never stored.

      Do not output anything.

    3. Only output the following , with the band matrix rendered as a Markdown table with aligned column edges:

      Band Matrix (rows: estimated, columns: actual):

      Est.XSSMLXL
      XS[...][...][...][...][...]
      [...][...][...][...][...][...]

      ● Hit Rate: % ● Bias: bands ● Rates: factor , file , line (current) → factor , file , line (fitted) ● Scale: <scale/> (current) → <suggested-scale/> (suggested alternative)

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: 196kUpdated Claude CodeCodexVerifiedInstall
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: 192kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 192kUpdated Claude CodeCodexVerifiedInstall
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: 192kUpdated Claude CodeCodexVerifiedInstall