Skip to content
Back to search

HumanCompiler

Compile humans into AI agents — a Claude Code plugin that conducts deep behavioral interviews and generates installable agent plugins

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/gerstep--humancompiler/badge.svg)](/listings/gerstep--humancompiler)

HTML

<a href="/listings/gerstep--humancompiler"><img src="/api/listings/gerstep--humancompiler/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

# 1. Install the plugin
claude --plugin-dir /path/to/HumanCompiler

# 2. Start the interview
/compile-human

# 3. After all 8 phases, install the generated agent
claude --plugin-dir ~/.human-compiler/<name>/output-plugin/<name>-agent

---

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 · 21 lines

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

  1. {
  2. "name": "HumanCompiler",
  3. "owner": {
  4. "name": "Gerstep"
  5. },
  6. "metadata": {
  7. "description": "Compile humans into AI agents through deep behavioral interviews"
  8. },
  9. "plugins": [
  10. {
  11. "name": "compile-human",
  12. "source": "./",
  13. "description": "Conduct deep behavioral interviews and generate installable Claude Code plugins that embody a person's decision-making, communication style, and expertise.",
  14. "version": "0.1.0",
  15. "homepage": "https://github.com/Gerstep/HumanCompiler",
  16. "repository": "https://github.com/Gerstep/HumanCompiler",
  17. "license": "MIT",
  18. "keywords": ["agent", "interview", "digital-twin", "compiler", "cowork"]
  19. }
  20. ]
  21. }
README.md · README · 247 lines

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

  1. ```
  2. ██╗ ██╗██╗ ██╗███╗ ███╗ █████╗ ███╗ ██╗
  3. ██║ ██║██║ ██║████╗ ████║██╔══██╗████╗ ██║
  4. ███████║██║ ██║██╔████╔██║███████║██╔██╗ ██║
  5. ██╔══██║██║ ██║██║╚██╔╝██║██╔══██║██║╚██╗██║
  6. ██║ ██║╚██████╔╝██║ ╚═╝ ██║██║ ██║██║ ╚████║
  7. ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═══╝
  8. ██████╗ ██████╗ ███╗ ███╗██████╗ ██╗██╗ ███████╗██████╗
  9. ██╔════╝██╔═══██╗████╗ ████║██╔══██╗██║██║ ██╔════╝██╔══██╗
  10. ██║ ██║ ██║██╔████╔██║██████╔╝██║██║ █████╗ ██████╔╝
  11. ██║ ██║ ██║██║╚██╔╝██║██╔═══╝ ██║██║ ██╔══╝ ██╔══██╗
  12. ╚██████╗╚██████╔╝██║ ╚═╝ ██║██║ ██║███████╗███████╗██║ ██║
  13. ╚═════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝╚══════╝╚═╝ ╚═╝
  14. ```
  15. **Compile humans into AI agents.**
  16. A Claude Code plugin that conducts deep behavioral interviews, reads work artifacts via MCP tools, and generates installable plugins that authentically embody a person's thinking, communication, and decision-making.
  17. ---
  18. ## How It Works
  19. ```
  20. ┌─────────────────────────────────┐
  21. │ /compile-human │
  22. └──────────────┬──────────────────┘
  23. │
  24. ┌──────────────▼──────────────────┐
  25. │ 8-Phase Deep Interview │
  26. │ │
  27. │ 1. Identity & Role │
  28. │ 2. Communication Style │
  29. │ 3. Decision-Making │
  30. │ 4. Domain Expertise │
  31. │ 5. Work Patterns │
  32. │ 6. Edge Cases │
  33. │ 7. Artifact Analysis (MCP) │
  34. │ 8. Calibration & Corrections │
  35. └──────────────┬──────────────────┘
  36. │
  37. ┌──────────────▼──────────────────┐
  38. │ MCP Source Analysis │
  39. │ │
  40. │ Notion ─── docs, meeting notes │
  41. │ Asana ──── tasks, projects │
  42. │ Chrome ─── web artifacts │
  43. │ Local ──── files, transcripts │
  44. └──────────────┬──────────────────┘
  45. │
  46. ┌──────────────▼──────────────────┐
  47. │ Behavioral Profile (YAML) │
  48. │ │
  49. │ ~/.human-compiler/<name>/ │
  50. │ ├── profile.yaml │
  51. │ ├── phases/ │
  52. │ └── artifacts/ │
  53. └──────────────┬──────────────────┘
  54. │
  55. ┌──────────────▼──────────────────┐
  56. │ Plugin Generator │
  57. │ │
  58. │ Profile ──► Handlebars ──► Plugin│
  59. └──────────────┬──────────────────┘
  60. │
  61. ┌──────────────▼──────────────────┐
  62. │ Installable Claude Code Plugin │
  63. │ │
  64. │ <name>-autonomous (acts) │
  65. │ <name>-advisory (advises) │
  66. │ /ask-<name> (consults) │
  67. └─────────────────────────────────┘
  68. ```
  69. ---
  70. ## Quick Start
  71. ```bash
  72. # 1. Install the plugin
  73. claude --plugin-dir /path/to/HumanCompiler
  74. # 2. Start the interview
  75. /compile-human
  76. # 3. After all 8 phases, install the generated agent
  77. claude --plugin-dir ~/.human-compiler/<name>/output-plugin/<name>-agent
  78. ```
  79. ---
  80. ## Features
  81. **Deep Behavioral Interview**
  82. - 8 structured phases covering identity, communication, decisions, expertise, workflows, edge cases
  83. - 10-20 adaptive questions per phase with follow-up probes
  84. - Concrete examples over abstractions — captures real behavior, not aspirations
  85. **MCP-Powered Artifact Analysis**
  86. - Reads Notion pages, meeting notes, strategy docs for communication style
  87. - Analyzes Asana tasks and projects for work patterns
  88. - Cross-references artifacts with interview answers for authenticity
  89. **Progressive & Resumable**
  90. - Saves after every phase — never lose progress
  91. - `/compile-human resume` picks up where you left off
  92. - `/compile-human status` shows progress at a glance
  93. **Configurable Autonomy**
  94. - **Autonomous mode** (`acceptEdits`): Agent acts, decides, and communicates as the person
  95. - **Advisory mode** (`plan`, read-only): Agent recommends in the person's style without acting
  96. **Marketplace-Ready Output**
  97. - Generates a complete Claude Code plugin with manifest, agents, skills, CLAUDE.md
  98. - Install via `--plugin-dir` or distribute through plugin marketplace
  99. ---
  100. ## Output Plugin Structure
  101. ```
  102. <name>-agent/
  103. ├── .claude-plugin/
  104. │ └── plugin.json # Plugin manifest
  105. ├── agents/
  106. │ ├── <name>-autonomous.md # Full autonomy agent
  107. │ └── <name>-advisory.md # Advisory-only agent
  108. ├── skills/
  109. │ ├── ask-<name>/
  110. │ │ └── SKILL.md # "What would <name> do?"
  111. │ └── <domain>-advice-<name>/
  112. │ └── SKILL.md # Expertise-specific skill
  113. └── CLAUDE.md # Agent documentation
  114. ```
  115. ---
  116. ## Commands
  117. | Command | Description |
  118. |---------|-------------|
  119. | `/compile-human` | Start a new interview |
  120. | `/compile-human resume` | Resume an interrupted interview |
  121. | `/compile-human status` | Check progress on all profiles |
  122. | `/compile-human generate` | Force-generate plugin from current profile |
  123. ---
  124. ## Architecture
  125. ```
  126. HumanCompiler/
  127. ├── .claude-plugin/plugin.json # Plugin manifest
  128. ├── skills/compile-human/
  129. │ ├── SKILL.md # Orchestrator skill
  130. │ ├── interview-guide.md # Interview methodology
  131. │ └── phase-instructions/ # Per-phase question banks
  132. │ ├── 01-identity.md
  133. │ ├── 02-communication.md
  134. │ ├── 03-decision-making.md
  135. │ ├── 04-domain-expertise.md
  136. │ ├── 05-work-patterns.md
  137. │ ├── 06-edge-cases.md
  138. │ ├── 07-artifact-analysis.md
  139. │ └── 08-calibration.md
  140. ├── agents/interviewer.md # Interview agent persona
  141. ├── scripts/
  142. │ ├── profile-manager.ts # Profile CRUD operations
  143. │ ├── profile-manager-cli.ts # CLI wrapper
  144. │ ├── generate-plugin.ts # Profile → Plugin generator
  145. │ └── templates/ # Handlebars templates
  146. │ ├── plugin.json.hbs
  147. │ ├── agent-autonomous.hbs
  148. │ ├── agent-advisory.hbs
  149. │ ├── skill-ask.hbs
  150. │ ├── skill-task.hbs
  151. │ └── claude-md.hbs
  152. ├── tests/ # Full test suite
  153. │ ├── profile-manager.test.ts
  154. │ ├── template-render.test.ts
  155. │ ├── generate-plugin.test.ts
  156. │ └── e2e-interview-flow.test.ts
  157. ├── package.json
  158. └── CLAUDE.md
  159. ```
  160. ---
  161. ## Profile Schema
  162. The behavioral profile captures:
  163. | Section | What it records |
  164. |---------|----------------|
  165. | **Identity** | Role, org, team, responsibilities, goals |
  166. | **Communication** | Writing style, tone spectrum, patterns, vocabulary |
  167. | **Decision-Making** | Framework, prioritization, uncertainty handling, tradeoffs |
  168. | **Expertise** | Domains (with depth), technical skills, industry knowledge |
  169. | **Work Patterns** | Daily routine, tools, collaboration, meetings, task management |
  170. | **Edge Cases** | Conflict resolution, ambiguity, failure response, scenarios |
  171. | **Artifacts** | Analyzed documents, cross-artifact patterns |
  172. | **Calibration** | Corrections, additions, confidence score |
  173. ---
  174. ## Development
  175. ```bash
  176. # Install dependencies
  177. bun install
  178. # Run tests
  179. bun test
  180. # Run specific test suite
  181. bun test profile-manager
  182. bun test template-render
  183. bun test generate-plugin
  184. bun test e2e
  185. # Generate a plugin from a profile
  186. bun run scripts/generate-plugin.ts ~/.human-compiler/<name>/profile.yaml
  187. ```
  188. ---
  189. ## How the Interview Works
  190. Each phase follows a consistent pattern:
  191. 1. **Read phase instructions** — load the question bank and MCP guidance
  192. 2. **Query MCP sources** — search Notion, Asana, etc. for relevant artifacts
  193. 3. **Conduct adaptive interview** — ask questions, follow interesting threads
  194. 4. **Cross-reference artifacts** — validate answers against real work products
  195. 5. **Record structured data** — update the YAML profile
  196. 6. **Save raw transcript** — preserve the full conversation for reference
  197. 7. **Summarize and confirm** — present findings, ask for corrections
  198. 8. **Transition** — move to the next phase
  199. The final calibration phase presents the complete profile for review and correction, ensuring the compiled agent is authentically representative.
  200. ---
  201. ## License
  202. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

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