AI Second Brain PRD Generator
Fill out a requirements template and Claude Code generates a personalized 9-phase build plan for a proactive AI second brain with persistent memory.
The skill only reads a user template and writes a PRD — no destructive operations, no credential requests, narrow permission surface; the architecture reference shows strong security awareness (key isolation, injection guardrails, SOUL.md write-protection, dangerous-command blocking). However, the generated PRD directs building proactive agents with external platform access (Gmail/Slack), and Partner mode can send messages; actual safety depends entirely on later implementation, with no confirmation or rollback design in this skill itself.
Instructions are self-consistent, workflow steps and parameters are explicit, and missing input is handled by pointing to the bundled template; PRD structure is well specified. But it is pure prompt instructions: no executable scripts, no tests, no failure-handling paths, and output depends on runtime web research whose quality is uncontrollable and statically unreproducible — capped by the static ceiling.
Trigger conditions are explicit (completed template, slash command, multiple semantic triggers), audience and scenario are clear, with a full blank template and worked example. No declared non-fit boundaries, and core function depends entirely on Claude Code/Anthropic ecosystem plus English web research, creating real reachability and language risk for mainland-China users.
Documentation is well layered: SKILL.md, blank template, example, and architecture reference with progressive disclosure; README covers install and usage. But license metadata is unknown, there is no version/changelog, no explicit maintenance responsibility or update path, and no FAQ or known-limitations section.
The goal (generate a personalized 9-phase PRD) is well defined and the template plus architecture reference plausibly support a structured output — a low-cost, high-leverage task. Yet static review cannot verify the actual usability or accuracy of generated PRDs, the mandatory 'research every API' step raises cost and variance, and no representative output evidence is provided.
Only a fabricated example (Alex Rivera) serves as an input sample; there is no real generated PRD, no tests, no third-party execution evidence, and no corroborating sources. Key claims such as ~$0.05/run cost estimates are unsourced.
- This is a static source review; the skill was not executed and generated-PRD quality was not verified.
- The generated PRD directs building proactive agents with access to sensitive platforms (Gmail/Slack); start at Observer/Advisor level and escalate permissions gradually.
- Core function depends entirely on the Claude Code/Anthropic ecosystem and English web research; mainland-China reachability and Chinese-language support are unverified.
- Repository license is undeclared; confirm licensing terms before enterprise use.
- Security boundaries at the Partner (autonomous) level depend entirely on later implementation quality; default to lower autonomy levels.
What does this skill do, and when should you use it?
This is a Claude Code skill that doesn't build a second brain itself — it generates a personalized Product Requirements Document (PRD) from a requirements template you fill out. The PRD covers nine phases: memory layer, hooks, hybrid RAG memory search, platform integrations, skills, a proactive heartbeat system, chat interface, security hardening, and deployment. The skill web-researches every tool and API in your stack so each phase contains specific, implementable guidance. It's aimed at developers willing to build the system themselves with the Claude Agent SDK from a detailed blueprint, not at users wanting a turnkey product.
Reads your completed my-second-brain-requirements.md (8 sections: about you, platforms, top tasks, proactivity level, security boundaries, memory categories, infrastructure, integration priority); loads a bundled architecture reference; web-researches the Claude Agent SDK, FastEmbed, and every platform you selected (Gmail, Slack, Linear, etc.) to verify auth methods, SDKs, endpoints, and rate limits; then generates a 9-phase PRD at .agent/plans/second-brain-prd.md where each phase includes what to build, key file paths, dependencies, complexity estimates, and personalization notes derived from your answers.
- An indie developer who wants a persistent AI assistant that checks email, calendar, and tasks every 30 minutes and proactively notifies them
- A freelancer who wants the AI to draft Gmail or Slack replies in their own voice for review before sending (Advisor mode)
- A heavy Obsidian user who wants to extend their vault into a long-term memory system with hybrid semantic search
- A Dynamous community member preparing for Cole Medin's second brain workshop who needs a phased blueprint
- A consultant or founder choosing Partner mode so the AI sends low-risk messages and completes routine tasks autonomously
What are this skill's strengths and limitations?
- The PRD is genuinely personalized: paths use your vault name, phases are ordered by your integration priority, and proactivity level maps to concrete behaviors
- Mandates live research per platform, capturing auth flows, SDKs, and rate limits rather than generic advice
- Security design is specific and deep: a credential-blocking hook, a named DANGEROUS_BASH_PATTERNS list, a pre-flight guardrail agent, and 3-layer external data sanitization
- Addresses real engineering pitfalls: heartbeat state diffing to prevent notification fatigue, file locking against concurrent corruption, and a git concat-both merge driver for log conflicts
- It only produces the plan document — you still have to implement all nine phases yourself or with a coding agent
- Deeply tied to Claude Code and the Claude Agent SDK (hooks, SessionStart injection, $CLAUDE_SKILL_DIR); porting to another platform requires substantial rework
- No topics, unknown license, and no test suite or maturity evidence in the source
- The full system spans Python, FastEmbed, SQLite/Postgres and more — meaningful maintenance burden; the 30-minute heartbeat incurs ongoing API costs (~$0.05/run per the README)
How do you install this skill?
1) Clone the repo: git clone https://github.com/coleam00/second-brain-starter.git; 2) Copy the skill into your project: cp -r second-brain-starter/.claude/skills/create-second-brain-prd your-project/.claude/skills/create-second-brain-prd; 3) Copy the requirements template: cp .claude/skills/create-second-brain-prd/my-second-brain-requirements.md ./my-second-brain-requirements.md. The license is not stated in the source; verify before adopting.
How do you use this skill?
1) Fill out all 8 template sections (a completed example is at example-my-second-brain-requirements.md in the skill directory); 2) Open Claude Code in your project and run /create-second-brain-prd ./my-second-brain-requirements.md; 3) Claude reads your requirements, loads the architecture reference, researches your stack, and writes a 9-phase PRD to .agent/plans/second-brain-prd.md; 4) Build phase by phase, optionally starting from the templates/memory/ folder (BOOTSTRAP.md, SOUL.md, USER.md, etc.).
How does this skill compare with similar options?
The README explicitly compares against an MCP tool-call approach for the heartbeat, claiming ~$0.05/run with this design's Python data-gathering plus a single Claude reasoning call versus ~$0.38 with MCP tool calls.