Skip to content
Back to search

swe-interview-coach

Turn Claude Code into your SWE interview coach — behavioral, system design & coding training/mocks, all local.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/kirilxd--swe-interview-coach/badge.svg)](/listings/kirilxd--swe-interview-coach)

HTML

<a href="/listings/kirilxd--swe-interview-coach"><img src="/api/listings/kirilxd--swe-interview-coach/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
  3. "name": "kirilxd-plugins",
  4. "owner": {
  5. "name": "kirilxd"
  6. },
  7. "plugins": [
  8. {
  9. "name": "swe-interview-coach",
  10. "version": "1.0.0",
  11. "source": {"source": "github", "repo": "kirilxd/swe-interview-coach"},
  12. "description": "SWE interview prep — behavioral (STAR story bank, company-tailored mocks, debriefs), system design (canonical walkthroughs, graded mocks on a local Excalidraw canvas), and coding (DSA walkthroughs, graded mocks with a local test harness that runs your code, drills, LeetCode import)"
  13. }
  14. ]
  15. }
README.md · README · 187 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <h1 align="center">swe-interview-coach</h1>
  2. <p align="center">Turn Claude Code into your SWE interview coach — behavioral, system design & coding mocks, all local.</p>
  3. <p align="center">
  4. <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT License"></a>
  5. <img src="https://img.shields.io/badge/Claude_Code-2.0+-7C3AED.svg" alt="Claude Code 2.0+">
  6. <img src="https://img.shields.io/badge/version-1.0.0-green.svg" alt="v1.0.0">
  7. </p>
  8. ## Get started in 10 seconds
  9. ```
  10. /plugin marketplace add kirilxd/swe-interview-coach
  11. /plugin install swe-interview-coach@kirilxd-plugins
  12. ```
  13. Then open Claude Code in your interview-prep directory (e.g., `~/Documents/interview/`) and run:
  14. ```
  15. /story-add ~/Documents/your-resume.pdf
  16. ```
  17. ## What it does
  18. Builds a canonical bank of STAR stories from your résumé or experience, maps them to each company you're targeting (with their values and JD), runs realistic mock interviews, drills story delivery, and captures learnings from real interviews. Everything is plain markdown in your working directory — you can edit anything in `vim` and the plugin still works.
  19. ## Interview modes
  20. | Mode | Status | What it covers |
  21. |---|---|---|
  22. | **Behavioral** | ✅ Available | STAR story bank, company-tailored mocks, delivery rehearsal, real-interview debriefs |
  23. | **System Design** | ✅ Available | Canonical design walkthroughs, mock + practice on a shared local Excalidraw canvas (you draw, the agent draws — live in your browser), real-interview debriefs |
  24. | **Coding** | ✅ Available | DSA pattern walkthroughs, guided practice + graded mocks with a local test harness that runs your code, rapid drills, real-interview debriefs, optional LeetCode import |
  25. | **Take-home** | 🚧 Planned | Spec-scoping interview, pre-submission review against rubric |
  26. The data layout under `~/Documents/interview/` is designed for these modes from day one — adding a `take-home/` subtree later requires no migration.
  27. ## Behavioral commands
  28. | Command | What it does | Example |
  29. |---|---|---|
  30. | `/story-add [resume]` | Extract a STAR story; cold mode or CV-grounded if you pass a PDF | `/story-add ~/cv.pdf` |
  31. | `/story-import <file>` | One-shot migration of legacy STAR-stories markdown | `/story-import <company_name>-stories.md` |
  32. | `/story-map <company> [jd]` | Tailor every canonical story to a company and JD; cache company values | `/story-map <company_name> <url>` |
  33. | `/mock-behavioral <company> [job-title]` | Realistic 5–7 question mock; scored debrief | `/mock-behavioral <company_name>` |
  34. | `/story-rehearse <id> [variant]` | Drill one variant for filler, ramble, metrics, pronoun discipline | `/story-rehearse <company_name>-ui-library platform-driving-adoption` |
  35. | `/debrief <company> [job-title]` | Post-real-interview capture; updates question bank with new gaps | `/debrief <company_name>` |
  36. ## Sysdesign commands
  37. | Command | What it does | Example |
  38. |---|---|---|
  39. | `/sysdesign-explain <design>` | Canonical senior-engineer walkthrough; the agent builds the diagram on the canvas as it teaches | `/sysdesign-explain twitter-feed` |
  40. | `/practice-sysdesign [design]` | Guided, untimed practice; the agent scribes your described architecture, hints freely | `/practice-sysdesign url-shortener` |
  41. | `/mock-sysdesign [design]` | Graded 45-min mock; you draw, the agent probes, then scores a 6-axis rubric + annotates your diagram | `/mock-sysdesign uber-dispatch` |
  42. | `/debrief-sysdesign <company> [topic]` | Capture a real interview afterward — problem, approach, stuck points, gut outcome | `/debrief-sysdesign <company_name> rate-limiter` |
  43. | `/sysdesign-canvas` | Manually (re)start the canvas + open the browser tab (rarely needed) | `/sysdesign-canvas` |
  44. ### How the canvas works
  45. <p align="center">
  46. <img src="assets/sysdesign-canvas.png" alt="A news-feed fan-out architecture drawn on the local Excalidraw canvas" width="780">
  47. </p>
  48. The first sysdesign command you run boots a tiny bundled Node-stdlib server (`scripts/canvas-server.js`) on http://localhost:9999 and opens a browser tab. Excalidraw loads once from a pinned CDN (esm.sh) and is then browser-cached — only the first load needs internet. The scene syncs **both directions** through one local JSON file, `~/.config/swe-interview-coach/canvas.json`: the agent's writes appear in your browser within ~500 ms, and your edits post back within ~300 ms. Roles shift per mode — **explain:** the agent draws; **practice:** the agent scribes and you can edit alongside it; **mock:** you draw while the agent observes, then annotates afterward. Prerequisites are just `node`, `lsof`, and a browser. There is **no MCP, no `npm install`, and no `/reload-plugins`** — the script is plain Node standard library.
  49. ## Coding commands
  50. | Command | What it does | Example |
  51. |---|---|---|
  52. | `/coding-explain <pattern>` | Canonical senior-engineer walkthrough of a DSA pattern, worked on a representative problem | `/coding-explain sliding-window` |
  53. | `/practice-coding [problem]` | Guided, untimed practice; seeds `solution.py` you edit in your own editor, hints freely | `/practice-coding two-sum` |
  54. | `/mock-coding [problem]` | Graded mock; you code in `solution.py`, the coach probes, runs it against the bundled cases, then scores | `/mock-coding coin-change` |
  55. | `/coding-drill <pattern>` | Rapid-fire reps on a pattern (or your weak patterns); recall, complexity, edge cases | `/coding-drill dynamic-programming` |
  56. | `/debrief-coding <company> [problem]` | Capture a real coding interview afterward — problem, approach, stuck points, gut outcome | `/debrief-coding <company_name> two-sum` |
  57. | `/coding-import <leetcode-url \| slug \| daily>` | Import a public LeetCode problem into your local library via a read-only fetch; becomes a normal practice/mock problem | `/coding-import two-sum` |
  58. ### How the test harness works
  59. A practice or mock session seeds a `solution.py` in the session folder; you edit it in your own editor (vim, VS Code, whatever). On a mock, the coach runs your solution against the problem's bundled test cases through a tiny bundled Python-stdlib runner (`scripts/run-solution.sh` → `scripts/harness/python_runner.py`) and scores correctness from the result. The only prerequisite is **`python3` on your PATH**; if it isn't available the harness degrades gracefully to a read-only review of your code — coaching never aborts over a missing runtime. There is **no MCP, no `npm install`, and no server** — it's plain Python standard library that runs entirely on your machine.
  60. ## The behavioral prep loop
  61. ```
  62. build → map → mock → drill → debrief → repeat
  63. ```
  64. 1. **Build your bank** — `/story-add` (with résumé) or `/story-import` (from existing notes). Each story can have multiple framings ("variants") tuned to different question themes.
  65. 2. **Map for the target** — `/story-map <company_name> <jd-url>` researches <company_name>'s values, fetches the JD, tailors every story, and builds a question index with coverage gaps.
  66. 3. **Mock it** — `/mock-behavioral <company_name>` runs an interview as a <company_name> engineer. Asks 5–7 questions with follow-ups. Scores STAR clarity, metric quality, conciseness, and values alignment on a 1–5 rubric.
  67. 4. **Drill the weak spots** — `/story-rehearse <id> <variant>` for delivery polish. The mock's coach notes tell you exactly which variants to drill.
  68. 5. **Debrief after real interviews** — `/debrief <company_name>` captures the actual questions asked, what stories you told, what surprised you. New questions feed back into the bank for next time.
  69. ## The sysdesign prep loop
  70. ```
  71. explain → practice → mock → debrief → repeat
  72. ```
  73. 1. **Learn the pattern** — `/sysdesign-explain twitter-feed` walks you through a canonical design senior-engineer style, drawing the architecture on the canvas as it teaches.
  74. 2. **Practice untimed** — `/practice-sysdesign url-shortener` lets you talk through an architecture while the agent scribes your boxes and arrows and hints freely whenever you're stuck.
  75. 3. **Mock under pressure** — `/mock-sysdesign uber-dispatch` runs a graded 45-minute mock: you drive the diagram, the agent probes, then scores a 6-axis rubric and annotates your canvas.
  76. 4. **Debrief after real interviews** — `/debrief-sysdesign <company_name> rate-limiter` captures the actual problem, your approach, where you got stuck, and your gut on the outcome.
  77. ## The coding prep loop
  78. ```
  79. explain → practice → mock → drill → debrief → repeat
  80. ```
  81. 1. **Learn the pattern** — `/coding-explain sliding-window` walks you through a DSA pattern senior-engineer style, worked on a representative problem so you internalize the shape, not just one answer.
  82. 2. **Practice untimed** — `/practice-coding two-sum` seeds a `solution.py` you edit in your own editor while the coach guides you and hints freely whenever you're stuck.
  83. 3. **Mock under pressure** — `/mock-coding coin-change` runs a graded mock: you code in `solution.py`, the coach probes, then runs your code against the bundled cases and scores correctness, complexity, and communication.
  84. 4. **Drill the weak spots** — `/coding-drill dynamic-programming` runs rapid-fire reps on a pattern; with no argument it targets the patterns your mocks flagged as weak.
  85. 5. **Debrief after real interviews** — `/debrief-coding <company_name> two-sum` captures the actual problem, your approach, where you got stuck, and your gut on the outcome.
  86. ## Your data stays local
  87. All state lives in your working directory (typically `~/Documents/interview/`). No hidden home directory, no JSON, no database.
  88. ```
  89. ~/Documents/interview/
  90. ├── behavioral/
  91. │ ├── stories/ # canonical STAR bank (cross-company)
  92. │ │ └── <company_name>-ui-library.md
  93. │ └── rehearsals/ # canonical drill sessions
  94. ├── sysdesign/
  95. │ └── sessions/ # cross-company practice & mock runs
  96. │ ├── 2026-06-13-mock-sysdesign/ # transcript.md + canvas.excalidraw + canvas-annotated.excalidraw
  97. │ └── 2026-06-13-practice-sysdesign/ # transcript.md + canvas.excalidraw
  98. ├── coding/
  99. │ ├── sessions/ # cross-company practice & mock runs
  100. │ │ ├── 2026-06-13-mock-coding/ # solution.py + transcript.md (with rubric)
  101. │ │ └── 2026-06-13-practice-coding/ # solution.py + transcript.md
  102. │ ├── drills/ # rapid-fire pattern reps
  103. │ │ └── 2026-06-13-drill-dynamic-programming.md
  104. │ ├── imported/ # /coding-import'ed LeetCode problems
  105. │ │ └── two-sum.md
  106. │ └── weak-patterns.md # rolling tracker of flagged patterns
  107. ├── <company_name>/
  108. │ ├── values.md # cached company culture/values
  109. │ ├── jds/
  110. │ │ └── senior-fe-engineer.md # JDs you've prepped for
  111. │ ├── behavioral/
  112. │ │ ├── mapped-stories/
  113. │ │ │ └── senior-fe-engineer/ # company-tailored variants
  114. │ │ └── sessions/ # mocks, mapped rehearsals, debriefs
  115. │ ├── sysdesign/
  116. │ │ └── sessions/
  117. │ │ └── 2026-06-13-debrief-sysdesign.md
  118. │ └── coding/
  119. │ └── sessions/
  120. │ └── 2026-06-13-debrief-coding.md
  121. └── <company_name>/
  122. └── (same per-company structure)
  123. ```
  124. Markdown with YAML frontmatter throughout. The `coding/` mode now sits alongside `behavioral/` and `sysdesign/` under each company directory the same way; `take-home/` will slot in later with no migration.
  125. ## Privacy
  126. - Everything stays on your machine. No data is sent to external services beyond the standard Claude Code conversation.
  127. - Company values caches use `WebSearch` and `WebFetch` for the same company-facing pages a human would Google.
  128. - Your résumé is read locally via Claude's Read tool; only excerpts you discuss are processed.
  129. - The sysdesign canvas runs entirely on `localhost:9999` via a bundled stdlib Node script; scene state lives in `~/.config/swe-interview-coach/canvas.json` and never leaves your machine. The Excalidraw library is fetched once from a pinned esm.sh CDN and then cached, and canvas exports save into your working dir's session folders.
  130. - The coding test harness runs your code locally via a bundled Python stdlib script; nothing is sent anywhere. It executes code **without a sandbox** (full local filesystem/network access), so only run solutions you trust — this is your own code on your own machine. `/coding-import` is the only coding command that reaches the network, doing a read-only public fetch (`WebFetch`) of a LeetCode problem page — no login, no submission.
  131. ## Local development
  132. ```bash
  133. claude --plugin-dir ~/Documents/swe-interview-coach
  134. ```
  135. After editing any command, agent, or skill file, run `/reload-plugins` in your session.
  136. ## Uninstalling
  137. ```
  138. /plugin uninstall swe-interview-coach@kirilxd-plugins
  139. /plugin marketplace remove kirilxd-plugins
  140. ```
  141. To remove your interview data: `rm -rf ~/Documents/interview/` (and any per-company subdirs you've created).
  142. ## License
  143. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.