A reference implementation of a personal AI collaborator built on Claude Code. This repo documents the architecture, patterns, and configuration that turns Claude Code from a coding assistant into a full strategic collaborator.
Built in 28 days. 539 commits. 30 custom skills. 23 behavioral rules. 9 automation hooks. 5 specialized subagents. ~34,600 lines of configuration and automation.
This is a real system, not a tutorial. It runs a solo founder's entire operation: morning briefings, content pipeline, product analytics, engagement scanning, deployment automation, and strategic decision-making. The AI agent has a defined personality, decision authority framework, and knows when to act autonomously versus when to ask.
This repo contains sanitized versions of the actual configuration files, with personal details replaced by framework templates. The best way to use it: give Claude Code the URL and ask it to analyze your setup against these patterns. It'll tell you what's worth adopting and what to skip. See Getting Started for the prompt.
The fastest way to learn from this repo is to point Claude Code at it and ask for recommendations tailored to your project.
Open Claude Code in your project directory and paste this:
Analyze my current Claude Code setup (CLAUDE.md, .claude/ directory, and codebase) and
compare it against the reference implementation at https://github.com/jonathanmalkin/jules.
1. Read my existing configuration and understand my project, workflow, and goals.
2. Fetch and study the Jules repo README, CLAUDE.md, profiles/, .claude/rules/,
.claude/hooks/, .claude/skills/, and .claude/agents/ to understand the patterns
and architecture.
3. Identify the highest-impact improvements I could make, prioritized by:
- What I'm missing entirely (e.g., no safety hooks, no decision framework)
- What I have but could strengthen (e.g., thin CLAUDE.md, no agent personality)
- What's in Jules that doesn't apply to my situation (skip these)
4. Give me a concrete, prioritized action plan. Start with 2-3 changes I can make today.
Don't try to replicate the whole system. Tell me what would actually help MY setup.
This works because Claude Code can fetch the repo, read your local config, and bridge the gap with specific recommendations.
If you prefer to browse and borrow directly:
- Fork this repo
- Copy the
.claude/directory structure into your project - Edit
CLAUDE.mdwith your agent's identity and your working style - Fill in the profile templates in
profiles/ - Start with 2-3 skills and expand based on what you actually need
- Add rules as patterns emerge across sessions
- Add hooks for safety and automation only when the probabilistic version isn't reliable enough
Start small. The system grew to 30 skills and 23 rules over 28 days of daily use. Don't try to build the whole thing on day one.
.claude/
settings.json # Hook wiring, permissions, env vars (the glue)
skills/ # 30 custom skill definitions
rules/ # 23 behavioral rules
hooks/ # 9 automation hooks
agents/ # 5 specialized subagent definitions
profiles/ # Agent and user profile templates + examples
Documents/
Content-Pipeline/ # Content workflow (queue, ideas, drafts, published)
Engagement/ # Engagement scanning (reply queue, feedback)
Field-Notes/ # Session retros, decision log, briefing archives
CLAUDE.md # The master configuration (always-loaded context)
Terrain.md # Operational state template
Briefing.md # Daily briefing template (generated by good-morning skill)
The .claude/ directory mirrors the exact structure Claude Code expects. Copy it into your project and the hooks, skills, rules, and agents work immediately.
A user-level settings example (profiles/examples/user-settings-example.json) shows permission patterns and deny rules for ~/.claude/settings.json, which applies across all your projects.
CLAUDE.md is the foundation. ~500 lines loaded into every session. It defines who the agent is, how it makes decisions, what it can do autonomously, and where the boundaries are. Think of it as the agent's constitution.
Skills are structured markdown files that define reusable capabilities. Each skill has a description (for triggering), instructions, and optionally supporting scripts. When you say /wrap-up, the agent loads the wrap-up skill and follows its playbook.
Rules fire on specific patterns. They're behavioral modifiers: "when you see X, do Y." Token efficiency, code intelligence preferences, safety constraints, editing conventions.
Hooks are shell scripts that run before or after tool calls. Pre-commit validation, bash command safety guards, output compression, clipboard handling. These are deterministic -- they execute the same way every time, unlike probabilistic skill instructions.
Agents are specialized subagent definitions with constrained tool access and specific models. A security reviewer that audits code changes. A content drafter that writes in a calibrated voice. A code reviewer that provides external perspective.
Profiles define the agent's identity and the user's context. The agent profile covers personality, voice, decision authority, and operational behaviors. The user profile provides values, goals, communication style, and failure modes the agent should watch for.
The most architecturally interesting piece. Every action falls into exactly one of two modes:
Just Do It -- Agent decides autonomously. All four criteria must be true:
- Two-way door (easily reversible)
- Within approved direction
- No external impact
- No emotional weight
Ask First -- Agent presents a Decision Card. Any single criterion triggers this:
- One-way door
- Involves money, legal, or external communication
- User-facing changes
- New strategic direction
- Agent is genuinely unsure
Standing Orders bridge the gap: pre-approved recurring autonomous actions with explicit bounds and conflict overrides. "Deploy to production after tests pass" is a standing order. "Deploy a new feature for the first time" triggers Ask First regardless.
| Skill | What It Does |
|---|---|
advisory |
Thinking partner for decisions, strategy, and research. Steelmans alternatives, runs pre-mortems, checks for cognitive bias. |
afternoon |
Afternoon operational scan. Pulls analytics, checks blockers, synthesizes mid-day status. |
agent-browser |
Browser automation library. Authentication, session management, form filling, video recording, snapshot-based navigation. |
catchup |
Reload essential context after /clear. Reads operational state, memory, and recent changes. |
check-updates |
Display the latest Claude Code change monitor report. Tracks upstream changes. |
content-marketing |
Content pipeline domain knowledge. Brand voice, content tracks, platform formatting, workflow modes, quality standards. |
copy-for |
Format text for a target platform (Discord, Reddit, LinkedIn, X) and copy to clipboard. |
deploy-app |
Validate locally, deploy to staging, smoke test, and (with approval) deploy to production. Full deployment pipeline. |
engage |
Scan Reddit, LinkedIn, and X for engagement opportunities. Draft response angles. |
executing-plans |
Execute a written implementation plan with human review between batches. |
generate-image-openai |
Generate images using OpenAI/DALL-E models via MCP server. |
good-morning |
Autonomous morning briefing. Pulls analytics, scans operational state, synthesizes priorities. |
growth-audit |
Structured growth analysis. Funnel metrics, bottleneck identification, RICE scoring, experiment design. |
post-article |
Post a queued article to Reddit and X. Cross-platform publishing flow. |
preview-report |
Generate and preview a daily analytics report email. |
reply-scout |
Scan Reddit and X for questions matching FAQ patterns. Draft replies, queue for approval. |
report-latest |
Pull latest analytics from production and report changes since last sync. |
retro-deep |
Deep retrospective. Forensic analysis of the current session -- issues, compliance gaps, patterns. Auto-applies fixes. |
review-plan |
Auto-tiered review for plans and architecture decisions. Classifies (Light/Standard/Deep) and runs proportional review. |
scope |
Scope and design implementation work before building. Explores requirements, challenges assumptions, produces validated designs. |
scout-techniques |
Scout for Claude Code technical insights. Searches Reddit, GitHub, HN for patterns worth adopting. |
smoke-test |
Browser-based smoke test against staging or production. Phased test methodology with automation scripts. |
subagent-driven-development |
Fast autonomous plan execution. Dispatch fresh subagents per task with two-stage review (spec + code quality). |
system-health |
System health diagnostic. Checks syntax, cross-references, freshness, deprecation candidates, configuration consistency. |
systematic-debugging |
Structured debugging methodology. Hypothesize, test, narrow. Prevents shotgun debugging. |
test-local-dev |
Test your app UI in the local development environment. Dev server startup, fast-forward, flow navigation. |
test-prod |
Smoke test or verify the app on staging or production. Full user flow verification. |
user-testing |
Persona-driven UX evaluation. Dispatches review groups covering 8 evaluation lenses. Returns structured problem/fix list. |
wrap-up |
End-of-session checklist. Commits, memory updates, operational state, session reports. Feeds the learning pipeline. |
writing-plans |
Design implementation plans for multi-step coding tasks. File-level change specs, dependency ordering, risk identification. |
Also available (not included): 4 Anthropic built-in skills (docx, pptx, xlsx, pdf) ship with Claude Code's skill system. 4 plugins (simplify, claude-api, claude-code-setup, skill-creator) are available via Claude Code's plugin system.
| Rule | Purpose |
|---|---|
1password |
1Password CLI integration patterns and vault reference conventions |
bash-prohibited-commands |
Document which commands are blocked by safety hooks and their substitutes |
browser-testing |
Conventions for browser-based testing (viewports, screenshots, selectors) |
business-principles |
Business operating principles that inform agent decision-making |
claude-cli-scripting |
Patterns for scripting Claude Code in CI, hooks, and automation |
code-intelligence |
Prefer LSP over grep for code navigation |
decision-gates |
Approval gates for irreversible or high-impact actions |
dotfiles |
Conventions for managing dotfiles and shell configuration |
editing-claude-config |
Safe patterns for editing Claude Code configuration files |
hosting-provider |
Server-specific conventions (SSH, file paths, deployment targets) |
intent-extraction |
Parse messy voice-dictated input correctly |
mcp-servers |
MCP server management conventions |
plan-execution |
Pre-check before implementing plans (prevent redundant work) |
plan-review-docs |
Standards for plan documents (structure, completeness, review) |
proactive-research |
Research instead of deflecting ("check the docs") |
production-deploys |
Production deployment safety conventions |
read-efficiency |
Grep before reading large files, delegate research to subagents |
skills |
Conventions for writing and maintaining skill definitions |
social-posting-automation |
Automation patterns for social media posting |
terrain-editing |
Conventions for updating operational state |
token-efficiency |
Compress bash output, select appropriate models for subagents |
wordpress-elementor |
WordPress/Elementor-specific editing patterns |
x-browser-posting |
Browser-based posting automation for X (Twitter) |
Hooks are shell scripts, but they're dead code without wiring. The included .claude/settings.json connects each hook to its trigger event. Without that file, none of these fire.
| Hook | Trigger | What It Does |
|---|---|---|
bash-safety-guard.sh |
PreToolUse: Bash | Blocks dangerous commands (rm, sudo, force-push, pipe-to-shell) |
bash-compress-hook.sh |
PreToolUse: Bash | Compresses verbose output (npm, git, docker) to save context |
pre-commit-verify.sh |
PreToolUse: Bash | Validates commits have proper messages and staged files |
clipboard-validate.sh |
PostToolUse: Bash | Validates and auto-copies generated content to clipboard |
pre-compact-save.sh |
PreCompact | Saves context before automatic compaction |
notify-input.sh |
Notification | Plays a sound when the agent needs user input |
cloud-bootstrap.sh |
SessionStart | Bootstraps environment for cloud/remote sessions |
plan-review-enforcer.sh |
PostToolUse: Write|Edit | Enforces plan review before implementation changes |
plan-review-gate.sh |
PreToolUse: ExitPlanMode | Gates execution on plan approval status |
| Agent | Model | Purpose |
|---|---|---|
security-reviewer |
Sonnet | Reviews code changes for vulnerabilities, data leakage, privacy violations |
content-marketing-draft |
Sonnet | Creative writing with voice calibration. Drafts, adapts, maintains consistency. |
content-marketing |
Haiku | Read-only content tasks. Backlog, inventory, calendar, monitoring. Cost-efficient. |
codex-review |
Haiku | External code review via OpenAI Codex CLI. Template -- update model names for your Codex version. |
app-tester |
Sonnet | Automated test suite runner. Knows the full testing matrix and selects the right subset. |
| File | Type | Description |
|---|---|---|
profiles/agent-profile.md |
Template | Agent identity: personality, voice, directives, autonomy rules |
profiles/user-profile.md |
Template | User context: values, goals, communication style, failure modes |
profiles/business-identity.md |
Template | Business identity: entity, products, audience, brand, operating principles |
profiles/goals.md |
Template | Goal framework: 4 pillars (Purpose, People, Profit, Health), quarterly cadence |
profiles/examples/agent-profile-example.md |
Example | "Ember" the owl -- shows the framework with a completely different personality |
profiles/examples/user-profile-example.md |
Example | Alex Chen -- solo game dev toolmaker, shows realistic user profile |
profiles/examples/business-identity-example.md |
Example | Pixel Forge Studios -- AI tools for indie game devs |
profiles/examples/goals-example.md |
Example | Quarterly goals across all 4 pillars with realistic progress tracking |
profiles/examples/user-settings-example.json |
Example | User-level ~/.claude/settings.json with permission patterns and deny rules |
Several skills read from and write to a Documents/ directory. Template files are included so skills work on first run.
| File | Used By | Purpose |
|---|---|---|
Content-Pipeline/Content-Queue.md |
content-marketing, engage, post-article | Priority-ordered posting queue |
Content-Pipeline/Content-Ideas.md |
content-marketing | Scored ideas backlog |
Content-Pipeline/Published-URLs.md |
engage, reply-scout, post-article | Published article URLs for linking in replies |
Engagement/reply-queue.md |
reply-scout | Pending drafted replies awaiting approval |
Engagement/feedback.md |
engage, reply-scout | Quality preferences and scoring calibration |
Field-Notes/Decision-Log.md |
decision-gates rule, wrap-up | Full rationale for significant decisions |
Skills also write to these directories (created with .gitkeep):
| Directory | Written By | Purpose |
|---|---|---|
Content-Pipeline/01-Drafts/Seeds/ |
good-morning, agent (content flagging) | Content seed ideas captured during sessions |
Content-Pipeline/03-Pending-Human-Review/ |
content-marketing | Articles awaiting editorial review |
Content-Pipeline/05-Published/ |
post-article | Published article archive |
Field-Notes/Logs/ |
wrap-up | Session reports |
Field-Notes/CC-Intelligence/ |
scout-techniques | Claude Code intelligence reports |
Identity persistence over memory. Memory is lossy. Context windows reset. The CLAUDE.md hierarchy solves this by loading ~500 lines of identity, decision rules, and behavioral patterns into every session. The agent doesn't need to remember who it is -- it's told every time.
Deterministic over probabilistic. When a pattern works, codify it into a script, not guidance. Skills and rules are probabilistic (the LLM might follow them). Hooks and scripts are deterministic (they execute the same way every time). Push behavior toward determinism whenever possible.
Configuration as codebase. The .claude/ directory is version-controlled, reviewed, and iterated on like any codebase. 539 commits in 28 days. The configuration IS the product.
Explicit autonomy boundaries. No ambiguity about what the agent can do on its own. The "Just Do It / Ask First" framework with standing orders eliminates the gray zone that makes autonomous agents unreliable.
Minimal engineering. Leverage Claude Code's built-in features (plan mode, auto memory, skills, rules) before building custom infrastructure. Don't build what a config option handles.
The right amount of complexity is the minimum needed for the current task. Three similar lines of code is better than a premature abstraction. A bash script that runs is better than a skill document the LLM might follow. Revenue is a signal, not a goal. Ship, see what happens, adjust.
Five skills in this system were adapted from Superpowers by Jesse Vincent (MIT License): scope, writing-plans, executing-plans, subagent-driven-development, and systematic-debugging. Each has been heavily customized but the core methodologies originate from that project.
MIT. Use it, adapt it, build on it.