claude-dev-env 1.35.0 → 1.36.1

package/skills/resume-review/SKILL.md

@@ -0,0 +1,261 @@
+---
+name: resume-review
+description: >-
+  Audit a resume for nitty-gritty offenses that bury signal. Resumes are
+  overviews scanned in 6-30 seconds, not detailed proof artifacts. This skill
+  identifies bullets that drift into workflow internals, multi-item technical
+  lists, library names, mechanism narration, or implementation detail, and
+  proposes tighter rewrites that keep the proof points (numbers, scope,
+  outcomes) while dropping the granular how-it-works text. Triggers:
+  "/resume-review", "review my resume", "audit this resume", "is my resume too
+  detailed", "tighten my resume bullets".
+---
+
+# Resume Review
+
+A resume is an **overview**. Hiring managers scan a resume in 6-30 seconds on
+first pass. Granular technical detail buries the signal. Stats, scope, and
+quantified outcomes belong on the resume; workflow internals, multi-item
+technical lists, and how-it-works narration belong in the interview.
+
+## Source authority
+
+Three established sources govern this skill. When a bullet violates one of
+these principles, cite the source in the review comment.
+
+- **Laszlo Bock**, *Work Rules!* (2015), Twelve Books, p. 71 (Bock served as
+  SVP People Operations at Google, 2006-2016): bullets describe "what you
+  accomplished, not what you did." Quantified outcomes beat task descriptions.
+- **Steve Dalton**, *The 2-Hour Job Search* (2012), Ten Speed Press, Ch. 3:
+  hiring managers initially scan a resume in 6-30 seconds. Granular technical
+  detail buries the signal in that scan.
+- **Lou Adler**, *Hire With Your Head* (4th ed., 2021), Wiley: bullets convey
+  **scope and impact**, not tools and tasks.
+
+## The principle
+
+Every bullet earns its place by carrying one of three things:
+
+1. **Scope** — what surface area of work this covered (catalog size, team
+   size, user count, transaction volume, geographic reach).
+2. **Impact** — the outcome the work produced (revenue, time saved, error
+   rate reduced, problem prevented, capability unlocked).
+3. **Quantified proof** — a single number that anchors scope or impact and
+   makes the bullet harder to dismiss as boilerplate.
+
+Bullets that describe the **mechanism** of how the work was done (workflow
+steps, internal architecture, library choices, sequencing of operations) fail
+the overview test. Move that content to the interview.
+
+## Offense categories
+
+The audit walks every bullet and flags any of these patterns. Each pattern
+has a fix template.
+
+### 1. Multi-item parenthetical lists
+
+A parenthetical that enumerates 3+ named items (tools, systems, features,
+sub-tasks).
+
+> **Offender:** "Built and maintain three production Python automation
+> systems (theme submission, theme exports, certification failure
+> processing) backed by a shared utility library."
+
+> **Fix:** Drop the parenthetical. Keep the count. "Built and maintain three
+> production Python automations handling [scope]."
+
+### 2. Workflow-step narration
+
+The bullet describes the sequence of operations the work performs.
+
+> **Offender:** "Manage Samsung's annual catalog-update cycle when 2,800+
+> themes must each be updated, exported, and resubmitted one by one within a
+> 1-2 month window."
+
+> **Fix:** Drop the workflow steps. Keep the scope numbers. "Manage Samsung's
+> annual catalog-update cycle: 2,800+ themes refreshed within a 1-2 month
+> window."
+
+### 3. Engineering-pattern jargon for non-engineering audience
+
+Multiple named technical patterns in one bullet, written for an audience
+that does not share the domain (e.g., infrastructure terms in an operations
+or trust-and-safety resume).
+
+> **Offender:** "Turn recurring failures into stronger error classification
+> (transient vs. permanent), circuit breakers, and checkpoint/resume
+> recovery."
+
+> **Fix:** Replace the pattern enumeration with a single capability noun.
+> "Turn recurring failures into reusable error-handling patterns so the same
+> failure does not happen twice."
+
+### 4. Mechanism narration
+
+The bullet explains how a tool or system internally works.
+
+> **Offender:** "Author and maintain pr-converge, a Claude Code skill that
+> automates the pull request review-and-fix loop until reviewers converge on
+> ready, with three open pull requests (11,000+ lines) actively extending
+> it."
+
+> **Fix:** State the outcome the skill produces. Drop the loop description.
+> "Author and maintain pr-converge, an open-source Claude Code skill that
+> drives draft pull requests to merge-ready autonomously."
+
+### 5. Library or tool names embedded mid-bullet
+
+A library, framework, or tool name appears inside a sentence about
+capability. Library names belong in the dedicated Tools section, not in
+capability bullets.
+
+> **Offender:** "Implemented authenticated workflows end-to-end: account
+> creation, token handling, local-first data with IndexedDB/Dexie, and
+> conflict-aware sync between client and server."
+
+> **Fix:** Drop the library names. State the capabilities. "Implemented
+> authentication, local-first data persistence, and conflict-aware
+> client-server sync end-to-end."
+
+### 6. Redundant statistics
+
+Two numbers in the same bullet that express the same quantity at different
+granularities.
+
+> **Offender:** "Roughly 30 new theme submissions per day (150 per week)."
+
+> **Fix:** Pick one. The daily number is usually the strongest scan signal.
+
+### 7. Implementation detail
+
+Phrases that describe how the work was built rather than what it does.
+
+> **Offender:** "Backed by a shared utility library, with zero manual
+> intervention beyond starting the script."
+
+> **Fix:** Drop the implementation phrase entirely. The capability statement
+> should stand on its own.
+
+### 8. Two-sentence bullets
+
+A bullet that requires two sentences usually carries one bullet of scope and
+one bullet of mechanism. The mechanism sentence should be removed, not
+combined.
+
+> **Offender:** "Author and maintain pr-converge, a Claude Code skill
+> that... [first sentence describes what]. Recent work adds mergeability
+> gates, GitHub Copilot reviewer integration, and post-convergence Copilot
+> follow-up across three open pull requests (11,000+ lines)."
+
+> **Fix:** Keep the capability sentence. Move the second sentence to a cover
+> letter or interview talking point.
+
+## Review protocol
+
+Walk this protocol against every bullet on the resume. Mark each bullet
+PASS, MINOR, or MAJOR.
+
+### Step 1: Scope check
+
+Read the bullet aloud in 4 seconds or less. If you cannot finish in 4
+seconds, the bullet is too long. **Action:** trim to one sentence under 25
+words unless the bullet carries a justified centerpiece (and centerpiece
+bullets stay under 40 words).
+
+### Step 2: Offense scan
+
+For each bullet, scan for the eight offense categories above. Record any
+hits with the category number.
+
+### Step 3: Verify proof points
+
+Every numeric claim in a bullet must be verifiable. If a number cannot be
+sourced, drop it. Hedging numbers ("roughly", "around", "approximately")
+are acceptable when the underlying number is verifiable but variable.
+
+### Step 4: Audience alignment
+
+For each bullet, ask: would the hiring manager for **this specific role**
+recognize the terms used? If the bullet uses domain language outside the
+target role's vocabulary (engineering jargon on a trust-and-safety resume,
+finance acronyms on an engineering resume), rewrite using domain-neutral
+capability nouns.
+
+### Step 5: Mechanism removal pass
+
+For each bullet that survived steps 1-4, ask: does this bullet describe
+**what** the work accomplished, or **how** the work was done? If it
+describes **how**, rewrite to describe **what** and move the **how** to
+interview prep notes.
+
+### Step 6: Section-level coherence
+
+After per-bullet review, scan each section. Check for:
+
+- **Bullet count consistency** — sections with similar weight should have
+  similar bullet counts. A 5-bullet section next to a 1-bullet section
+  signals imbalance.
+- **Voice consistency** — verb tense, sentence structure, and bullet length
+  should match across sections.
+- **Relevance ordering** — the most-relevant-to-the-target-role section
+  should appear first within its time band (Steve Dalton, *The 2-Hour Job
+  Search* §6: relevance over strict chronology when chronology does not
+  conflict).
+
+## Output format
+
+The audit produces a markdown report with this structure:
+
+```markdown
+# Resume Audit Report
+
+## Top offenders (worst first)
+
+### #1 — [Section] bullet [N]. [Severity]
+
+[Quote of current bullet]
+
+**Offenses:** [comma-separated category numbers]
+
+**Proposed rewrite:** [tighter version]
+
+**Words saved:** [N words → M words]
+
+(repeat for each offender)
+
+## Sections that pass
+
+- [Section name]: [bullet count] bullets, all PASS
+- (repeat)
+
+## Section-level findings
+
+[Coherence issues from Step 6, if any]
+
+## Sources cited
+
+- Bock, *Work Rules!* (2015), p. 71 — for offenses [N]
+- Dalton, *2-Hour Job Search* (2012), Ch. 3 — for offenses [N]
+- Adler, *Hire With Your Head* (2021) — for offenses [N]
+```
+
+## When this skill applies
+
+- User asks to review or audit a resume
+- User asks "is my resume too detailed"
+- User asks for tighter resume bullets
+- A resume document is shared and the user wants feedback
+- Before submitting a resume to a target role
+
+## When this skill does not apply
+
+- Cover letter review (use a separate cover-letter-review skill if needed)
+- Resume formatting fixes (font, spacing, layout) — this skill audits
+  content only
+- Resume creation from scratch — this skill assumes a draft exists
+
+## Triggers
+
+`/resume-review`, "review my resume", "audit this resume", "is my resume
+too detailed", "tighten my resume bullets", "what offenses do you see in my
+resume", "are my bullets too granular".

package/skills/bugteam/scripts/README.md

@@ -1,58 +0,0 @@
-# Bugteam utility scripts
-
-Scripts in this directory are **executed** by the lead or teammates. They are not loaded into context as instructions (see Anthropic [Skill authoring best practices — Progressive disclosure](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices#progressive-disclosure-patterns)).
-
-| Script | Purpose |
-|--------|---------|
-| `bugteam_preflight.py` | Run pytest (when configured) and optional `pre-commit` before `/bugteam`. |
-| `bugteam_fix_hookspath.py` | Auto-remediate a stale local `core.hooksPath` override, set canonical global value, re-run `bugteam_preflight.py`. Invoked by Claude when preflight reports a `core.hooksPath` failure. |
-| `bugteam_code_rules_gate.py` | Run `validate_content` from `code-rules-enforcer.py` on PR-scoped files (`git diff` vs merge-base). Exit `1` if any mandatory rule fails. Invoked **before each audit**; the fixer clears it before the auditor runs. |
-| `grant_project_claude_permissions.py` | Idempotent grant of Edit/Write/Read on `cwd/.claude/**` into `~/.claude/settings.json`. |
-| `revoke_project_claude_permissions.py` | Removes the matching grant entries from `~/.claude/settings.json`. |
-| `test_claude_permissions_common.py` | Pytest module for path normalization and glob-metacharacter guards in `_claude_permissions_common.py`. |
-| `_claude_permissions_common.py` | Shared helpers for the grant/revoke scripts (atomic JSON writes, settings sections). |
-
-## `bugteam_preflight.py`
-
-From the repository root:
-
-```bash
-python "${CLAUDE_SKILL_DIR}/scripts/bugteam_preflight.py"
-```
-
-- Skips pytest when `BUGTEAM_PREFLIGHT_SKIP=1`.
-- Skips pytest when `pytest.ini` / `pyproject.toml` exists but no `test_*.py` / `*_test.py` files are found under the repo root.
-- Pytest exit code `5` (no tests collected) is treated as success.
-- Add `--pre-commit` to run `pre-commit run --all-files` when `.pre-commit-config.yaml` exists.
-
-## `bugteam_fix_hookspath.py`
-
-From the repository root:
-
-```bash
-python "${CLAUDE_SKILL_DIR}/scripts/bugteam_fix_hookspath.py"
-```
-
-- Removes any local-scope `core.hooksPath` value that does not end in `hooks/git-hooks`.
-- Sets `git config --global core.hooksPath ~/.claude/hooks/git-hooks` when the global value is unset or non-canonical.
-- Refuses to run (exit non-zero) when `~/.claude/hooks/git-hooks` does not exist on disk — install via `npx claude-dev-env .` first.
-- Idempotent: a second invocation is a clean no-op.
-- Re-runs `bugteam_preflight.py --no-pytest` and propagates its exit code.
-
-The bugteam SKILL invokes this automatically when preflight stderr indicates a `core.hooksPath` failure, so Claude does not surface the error to the user.
-
-## `bugteam_code_rules_gate.py`
-
-From the repository root (same merge-base rules as the PR head vs base — default `--base origin/main`):
-
-```bash
-python "${CLAUDE_SKILL_DIR}/scripts/bugteam_code_rules_gate.py"
-```
-
-Optional explicit files instead of `git diff`:
-
-```bash
-python "${CLAUDE_SKILL_DIR}/scripts/bugteam_code_rules_gate.py" path/to/a.py path/to/b.ts
-```
-
-This loads `validate_content` from `hooks/blocking/code-rules-enforcer.py` inside `claude-dev-env` (same logic as the PreToolUse hook). Exit `0` = mandatory checks pass on scanned files; exit `1` = violations printed to stderr.

package/skills/bugteam/scripts/_claude_permissions_common.py

@@ -1,219 +0,0 @@
-"""Shared helpers for grant_project_claude_permissions and revoke_project_claude_permissions.
-
-Writes to ~/.claude/settings.json are atomic and permission-preserving: the
-target file's existing POSIX mode is captured, a sibling temp file is
-created via os.open with O_CREAT | O_EXCL and the preserved mode, content
-is written, then os.replace swaps it into place. Output is serialized with
-sort_keys=True for a stable on-disk layout; the first run on a hand-ordered
-settings file produces a one-time re-sort diff, subsequent writes are stable.
-"""
-
-import json
-import os
-import stat
-import sys
-from pathlib import Path
-from typing import NoReturn
-
-
-TEXT_FILE_ENCODING: str = "utf-8"
-PERMISSION_ALLOW_TOOLS: tuple[str, ...] = ("Edit", "Write", "Read")
-
-AUTO_MODE_ENVIRONMENT_ENTRY_TEMPLATE: str = (
-    "Trusted local workspace: {project_path}/.claude/** is the user's "
-    "project Claude Code config tree; edits inside are routine"
-)
-
-
-def exit_with_error(message: str) -> NoReturn:
-    print(f"Error: {message}", file=sys.stderr)
-    raise SystemExit(1)
-
-
-def path_contains_glob_metacharacters(candidate_path: str) -> bool:
-    glob_metacharacters_in_path: tuple[str, ...] = (
-        "*",
-        "?",
-        "[",
-        "]",
-        "(",
-        ")",
-        "{",
-        "}",
-        ",",
-    )
-    return any(
-        each_character in candidate_path
-        for each_character in glob_metacharacters_in_path
-    )
-
-
-def get_current_project_path() -> str:
-    normalized_project_path = str(Path.cwd()).replace("\\", "/")
-    if path_contains_glob_metacharacters(normalized_project_path):
-        raise ValueError(
-            f"Current directory path contains glob metacharacters and cannot "
-            f"be used to build permission rules safely: {normalized_project_path}"
-        )
-    return normalized_project_path
-
-
-def build_permission_rule(tool_name: str, project_path: str) -> str:
-    return f"{tool_name}({project_path}/.claude/**)"
-
-
-def build_permission_rules(
-    project_path: str, permission_allow_tools: tuple[str, ...]
-) -> list[str]:
-    return [
-        build_permission_rule(each_tool, project_path)
-        for each_tool in permission_allow_tools
-    ]
-
-
-def load_settings(settings_path: Path) -> dict[str, object]:
-    if not settings_path.exists():
-        return {}
-    parsed_settings: dict[str, object] = {}
-    try:
-        raw_text = settings_path.read_text(encoding=TEXT_FILE_ENCODING)
-    except OSError as read_error:
-        exit_with_error(f"Failed to read {settings_path}: {read_error}")
-    try:
-        parsed_settings = json.loads(raw_text)
-    except json.JSONDecodeError as decode_error:
-        exit_with_error(
-            f"Refusing to modify {settings_path}: existing file is not valid JSON "
-            f"({decode_error}). Fix or back up the file manually, then re-run."
-        )
-    if not isinstance(parsed_settings, dict):
-        exit_with_error(
-            f"Refusing to modify {settings_path}: existing file's root is "
-            f"{type(parsed_settings).__name__}, not a JSON object. Fix or back up "
-            f"the file manually, then re-run."
-        )
-    return parsed_settings
-
-
-def serialize_settings_to_json_text(settings: dict[str, object]) -> str:
-    json_indent_width_columns: int = len("  ")
-    return json.dumps(
-        settings,
-        indent=json_indent_width_columns,
-        sort_keys=True,
-    )
-
-
-def get_mode_to_preserve(settings_path: Path) -> int:
-    default_settings_file_mode: int = 0o600
-    try:
-        stat_result = os.stat(settings_path)
-    except FileNotFoundError:
-        return default_settings_file_mode
-    except OSError as stat_error:
-        exit_with_error(f"Failed to stat {settings_path}: {stat_error}")
-    return stat.S_IMODE(stat_result.st_mode)
-
-
-def write_atomically_with_mode(
-    temporary_path: Path, serialized_content: str, file_mode: int
-) -> None:
-    file_descriptor = os.open(
-        str(temporary_path),
-        os.O_WRONLY | os.O_CREAT | os.O_EXCL,
-        file_mode,
-    )
-    with os.fdopen(file_descriptor, "w", encoding=TEXT_FILE_ENCODING) as writer:
-        writer.write(serialized_content)
-
-
-def save_settings(settings_path: Path, settings: dict[str, object]) -> None:
-    atomic_write_temporary_suffix: str = ".tmp"
-    settings_path.parent.mkdir(parents=True, exist_ok=True)
-    serialized_settings = serialize_settings_to_json_text(settings)
-    temporary_path = settings_path.with_suffix(
-        settings_path.suffix + atomic_write_temporary_suffix
-    )
-    mode_to_preserve = get_mode_to_preserve(settings_path)
-    try:
-        try:
-            write_atomically_with_mode(
-                temporary_path, serialized_settings, mode_to_preserve
-            )
-            os.replace(str(temporary_path), str(settings_path))
-        except OSError as os_error:
-            exit_with_error(
-                f"Failed to write settings atomically to {settings_path}: {os_error}"
-            )
-    finally:
-        if temporary_path.exists():
-            try:
-                temporary_path.unlink()
-            except OSError:
-                pass
-
-
-def append_if_missing(target_list: list[object], new_value: str) -> bool:
-    if new_value in target_list:
-        return False
-    target_list.append(new_value)
-    return True
-
-
-def ensure_dict_section(
-    settings: dict[str, object], section_name: str
-) -> dict[str, object]:
-    """Return an existing dict section or create an empty one if absent.
-
-    A missing key and an explicit JSON null are treated identically: both
-    produce a fresh empty dict stored back into settings. Any other non-dict
-    value (string, list, number, bool) calls exit_with_error to avoid
-    overwriting user data.
-    """
-    existing_section = settings.get(section_name)
-    if existing_section is None:
-        replacement_section: dict[str, object] = {}
-        settings[section_name] = replacement_section
-        return replacement_section
-    if not isinstance(existing_section, dict):
-        exit_with_error(
-            f"Refusing to modify settings key {section_name!r}: existing value "
-            f"is {type(existing_section).__name__}, not a JSON object. Fix or "
-            f"remove the key manually, then re-run."
-        )
-    return existing_section
-
-
-def ensure_list_entry(section: dict[str, object], entry_name: str) -> list[object]:
-    """Return an existing list entry or create an empty one if absent.
-
-    A missing key and an explicit JSON null are treated identically: both
-    produce a fresh empty list stored back into the section. Any other
-    non-list value (string, dict, number, bool) calls exit_with_error to
-    avoid overwriting user data.
-    """
-    existing_entry = section.get(entry_name)
-    if existing_entry is None:
-        replacement_entry: list[object] = []
-        section[entry_name] = replacement_entry
-        return replacement_entry
-    if not isinstance(existing_entry, list):
-        exit_with_error(
-            f"Refusing to modify settings entry {entry_name!r}: existing value "
-            f"is {type(existing_entry).__name__}, not a JSON array. Fix or "
-            f"remove the entry manually, then re-run."
-        )
-    return existing_entry
-
-
-def prune_empty_list_then_empty_section(
-    settings: dict[str, object], section_key: str, list_key: str
-) -> None:
-    section = settings.get(section_key)
-    if not isinstance(section, dict):
-        return
-    list_entry = section.get(list_key)
-    if isinstance(list_entry, list) and len(list_entry) == 0:
-        del section[list_key]
-    if len(section) == 0:
-        del settings[section_key]