Digital Brain
- 33 installs
- 17.6k repo stars
- Updated August 2, 2026
- muratcankoylan/agent-skills-for-context-engineering
Helps with ai & agent building tasks during AI-assisted development.
About
digital-brain is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted coding.
- digital-brain
- AI & Agent Building
- AI-coding skill
Digital Brain by the numbers
- 33 all-time installs (skills.sh)
- +5 installs in the week ending Aug 4, 2026 (Skillselion tracking)
- Ranked #8,975 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
- Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/muratcankoylan/agent-skills-for-context-engineering --skill digital-brainAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 33 |
|---|---|
| repo stars | ★ 17.6k |
| Last updated | August 2, 2026 |
| Repository | muratcankoylan/agent-skills-for-context-engineering ↗ |
What it does
Helps with ai & agent building tasks during AI-assisted development.
Files
Digital Brain
A structured personal operating system for managing digital presence, knowledge, relationships, and goals with AI assistance. Designed for founders building in public, content creators growing their audience, and tech-savvy professionals seeking AI-assisted personal management.
Important: This skill uses progressive disclosure. Module-specific instructions are in each subdirectory's .md file. Only load what's needed for the current task.
When to Activate
Activate this skill when the user:
- Requests content creation (posts, threads, newsletters) - load identity/voice.md first
- Asks for help with personal brand or positioning
- Needs to look up or manage contacts/relationships
- Wants to capture or develop content ideas
- Requests meeting preparation or follow-up
- Asks for weekly reviews or goal tracking
- Needs to save or retrieve bookmarked resources
- Wants to organize research or learning materials
Trigger phrases: "write a post", "my voice", "content ideas", "who is [name]", "prepare for meeting", "weekly review", "save this", "my goals"
Core Concepts
Progressive Disclosure Architecture
The Digital Brain follows a three-level loading pattern:
| Level | When Loaded | Content |
|---|---|---|
| L1: Metadata | Always | This SKILL.md overview |
| L2: Module Instructions | On-demand | [module]/[MODULE].md files |
| L3: Data Files | As-needed | .jsonl, .yaml, .md data |
File Format Strategy
Formats chosen for optimal agent parsing:
- JSONL (
.jsonl): Append-only logs - ideas, posts, contacts, interactions - YAML (
.yaml): Structured configs - goals, values, circles - Markdown (
.md): Narrative content - voice, brand, calendar, todos - XML (
.xml): Complex prompts - content generation templates
Append-Only Data Integrity
JSONL files are append-only. Never delete entries:
- Mark as
"status": "archived"instead of deleting - Preserves history for pattern analysis
- Enables "what worked" retrospectives
Detailed Topics
Module Overview
digital-brain/
├── identity/ → Voice, brand, values (READ FIRST for content)
├── content/ → Ideas, drafts, posts, calendar
├── knowledge/ → Bookmarks, research, learning
├── network/ → Contacts, interactions, intros
├── operations/ → Todos, goals, meetings, metrics
└── agents/ → Automation scriptsIdentity Module (Critical for Content)
Always read `identity/voice.md` before generating any content.
Contains:
voice.md- Tone, style, vocabulary, patternsbrand.md- Positioning, audience, content pillarsvalues.yaml- Core beliefs and principlesbio-variants.md- Platform-specific biosprompts/- Reusable generation templates
Content Module
Pipeline: ideas.jsonl → drafts/ → posts.jsonl
- Capture ideas immediately to
ideas.jsonl - Develop in
drafts/usingtemplates/ - Log published content to
posts.jsonlwith metrics - Plan in
calendar.md
Network Module
Personal CRM with relationship tiers:
inner- Weekly touchpointsactive- Bi-weekly touchpointsnetwork- Monthly touchpointsdormant- Quarterly reactivation checks
Operations Module
Productivity system with priority levels:
- P0: Do today, blocking
- P1: This week, important
- P2: This month, valuable
- P3: Backlog, nice to have
Practical Guidance
Content Creation Workflow
1. Read identity/voice.md (REQUIRED)
2. Check identity/brand.md for topic alignment
3. Reference content/posts.jsonl for successful patterns
4. Use content/templates/ as starting structure
5. Draft matching voice attributes
6. Log to posts.jsonl after publishingPre-Meeting Preparation
1. Look up contact: network/contacts.jsonl
2. Get history: network/interactions.jsonl
3. Check pending: operations/todos.md
4. Generate brief with contextWeekly Review Process
1. Run: python agents/scripts/weekly_review.py
2. Review metrics in operations/metrics.jsonl
3. Check stale contacts: agents/scripts/stale_contacts.py
4. Update goals progress in operations/goals.yaml
5. Plan next week in content/calendar.mdExamples
Example: Writing an X Post
Input: "Help me write a post about AI agents"
Process: 1. Read identity/voice.md → Extract voice attributes 2. Check identity/brand.md → Confirm "ai_agents" is a content pillar 3. Reference content/posts.jsonl → Find similar successful posts 4. Draft post matching voice patterns 5. Suggest adding to content/ideas.jsonl if not publishing immediately
Output: Post draft in user's authentic voice with platform-appropriate format.
Example: Contact Lookup
Input: "Prepare me for my call with Sarah Chen"
Process: 1. Search network/contacts.jsonl for "Sarah Chen" 2. Get recent entries from network/interactions.jsonl 3. Check operations/todos.md for pending items with Sarah 4. Compile brief: role, context, last discussed, follow-ups
Output: Pre-meeting brief with relationship context.
Guidelines
1. Voice First: Always read identity/voice.md before any content generation 2. Append Only: Never delete from JSONL files - archive instead 3. Update Timestamps: Set updated field when modifying tracked data 4. Cross-Reference: Knowledge informs content, network informs operations 5. Log Interactions: Always log meetings/calls to interactions.jsonl 6. Preserve History: Past content in posts.jsonl informs future performance
Integration
This skill integrates context engineering principles:
- context-fundamentals - Progressive disclosure, attention budget management
- memory-systems - JSONL for persistent memory, structured recall
- tool-design - Scripts in
agents/scripts/follow tool design principles - context-optimization - Module separation prevents context bloat
References
Internal references:
- Identity Module - Voice and brand details
- Content Module - Content pipeline docs
- Network Module - CRM documentation
- Operations Module - Productivity system
- Agent Scripts - Automation documentation
External resources:
---
Skill Metadata
Created: 2024-12-29 Last Updated: 2024-12-29 Author: Murat Can Koylan Version: 1.0.0
# OS generated files
.DS_Store
.DS_Store?
._*
.Spotlight-V100
.Trashes
ehthumbs.db
Thumbs.db
# Editor directories
.idea/
.vscode/
*.swp
*.swo
*~
# Python
__pycache__/
*.py[cod]
*$py.class
.Python
*.so
.env
venv/
ENV/
# Node
node_modules/
npm-debug.log
yarn-error.log
# Personal data (uncomment if you want to keep local-only)
# content/drafts/*.md
# network/contacts.jsonl
# operations/metrics.jsonl
# Temporary files
*.tmp
*.temp
*.log
Digital Brain - Claude Instructions
This is a Digital Brain personal operating system. When working in this project:
Core Rules
1. Always read identity/voice.md before writing any content - Match the user's authentic voice 2. Append to JSONL files, never overwrite - Preserve history 3. Update timestamps when modifying tracked data 4. Cross-reference modules - Knowledge informs content, network informs operations
Quick Reference
- Writing content: Read
identity/voice.mdfirst, then use templates incontent/templates/ - Looking up contacts: Search
network/contacts.jsonl, checkinteractions.jsonlfor history - Content ideas: Check
content/ideas.jsonl, runagents/scripts/content_ideas.py - Task management: Use
operations/todos.md, align withoperations/goals.yaml - Weekly review: Run
agents/scripts/weekly_review.py
File Conventions
.jsonlfiles: One JSON object per line, append-only.mdfiles: Human-readable, freely editable.yamlfiles: Configuration and structured data_template.mdor_schemaentries: Reference formats, don't modify
When User Asks To...
| Request | Action |
|---|---|
| "Write a post about X" | Read voice.md → Draft → Match voice patterns |
| "Prepare for meeting with Y" | Look up contact → Get interactions → Summarize |
| "What should I create?" | Run content_ideas.py → Check calendar |
| "Add contact Z" | Append to contacts.jsonl with full schema |
| "Weekly review" | Run weekly_review.py → Present insights |
Agent Automation
Scripts and workflows that help maintain and leverage your Digital Brain.
Available Scripts
| Script | Purpose | Frequency |
|---|---|---|
weekly_review.py | Generate weekly review from data | Weekly |
content_ideas.py | Generate content ideas from knowledge | On-demand |
stale_contacts.py | Find contacts needing outreach | Weekly |
metrics_snapshot.py | Compile metrics for tracking | Weekly |
idea_to_draft.py | Expand an idea into a draft | On-demand |
How to Use
Scripts are in agents/scripts/. They work with your Digital Brain data and can be run by the agent when needed.
Running Scripts
# Agent can execute scripts directly
python agents/scripts/weekly_review.py
# Or with arguments
python agents/scripts/content_ideas.py --pillar "ai_agents" --count 5Script Outputs
Scripts output to stdout in a format the agent can process. They may also write to files when appropriate (e.g., generating a review document).
Agent Instructions
<instructions> When using automation scripts:
1. Weekly review: Run every Sunday, outputs review template with data filled in 2. Content ideas: Use when user asks for ideas, leverages knowledge base 3. Stale contacts: Run weekly, surfaces relationships needing attention 4. Metrics snapshot: Run weekly to append to metrics.jsonl 5. Idea to draft: Use when user wants to develop a specific idea
Scripts read from Digital Brain files and output actionable results. </instructions>
Workflow Automations
Sunday Weekly Review
1. Run metrics_snapshot.py to update metrics.jsonl
2. Run stale_contacts.py to identify outreach needs
3. Run weekly_review.py to generate review document
4. Present summary to userContent Ideation Session
1. Read recent entries from knowledge/bookmarks.jsonl
2. Check content/ideas.jsonl for undeveloped ideas
3. Run content_ideas.py for fresh suggestions
4. Cross-reference with content calendarPre-Meeting Prep
1. Look up contact in network/contacts.jsonl
2. Pull recent interactions from network/interactions.jsonl
3. Check any pending todos involving them
4. Generate brief with contextCustom Script Development
To add new scripts: 1. Create Python file in agents/scripts/ 2. Follow existing patterns (read JSONL, output structured data) 3. Document in this file 4. Test with sample data
#!/usr/bin/env python3
"""
Content Ideas Generator
Generates content ideas based on knowledge base and past successful content.
"""
import json
import argparse
from datetime import datetime
from pathlib import Path
BRAIN_ROOT = Path(__file__).parent.parent.parent
def load_jsonl(filepath):
"""Load JSONL file, skipping schema lines."""
items = []
if not filepath.exists():
return items
with open(filepath, 'r') as f:
for line in f:
line = line.strip()
if not line:
continue
try:
data = json.loads(line)
if '_schema' not in data:
items.append(data)
except json.JSONDecodeError:
continue
return items
def get_top_performing_content():
"""Get posts with highest engagement."""
posts = load_jsonl(BRAIN_ROOT / 'content' / 'posts.jsonl')
# Sort by engagement metrics if available
def engagement_score(post):
metrics = post.get('metrics', {})
return (
metrics.get('likes', 0) +
metrics.get('comments', 0) * 2 +
metrics.get('reposts', 0) * 3
)
sorted_posts = sorted(posts, key=engagement_score, reverse=True)
return sorted_posts[:5]
def get_recent_bookmarks(category=None):
"""Get recent bookmarks, optionally filtered by category."""
bookmarks = load_jsonl(BRAIN_ROOT / 'knowledge' / 'bookmarks.jsonl')
if category:
bookmarks = [b for b in bookmarks if b.get('category') == category]
# Sort by date, most recent first
bookmarks.sort(key=lambda x: x.get('saved_at', ''), reverse=True)
return bookmarks[:10]
def get_undeveloped_ideas():
"""Get ideas that haven't been developed yet."""
ideas = load_jsonl(BRAIN_ROOT / 'content' / 'ideas.jsonl')
raw_ideas = [i for i in ideas if i.get('status') == 'raw']
return raw_ideas
def generate_suggestions(pillar=None, count=5):
"""Generate content suggestions."""
output = f"""
# Content Ideas Generator
Generated: {datetime.now().isoformat()}
Filter: {pillar or 'All pillars'}
## Based on Top Performing Content
"""
top_posts = get_top_performing_content()
if top_posts:
output += "\nYour best performing content themes:\n"
for post in top_posts[:3]:
output += f"- {post.get('pillar', 'Unknown')}: {post.get('type', 'post')}\n"
output += "\n**Suggestion**: Create more content in these high-performing areas.\n"
else:
output += "\nNo post history yet. Start creating!\n"
output += """
## From Your Knowledge Base
"""
bookmarks = get_recent_bookmarks(pillar)
if bookmarks:
output += "\nRecent topics you've been researching:\n"
for bm in bookmarks[:5]:
output += f"- {bm.get('title', 'Untitled')} ({bm.get('category', 'uncategorized')})\n"
if bm.get('key_insights'):
output += f" Key insight: {bm['key_insights'][0]}\n"
output += "\n**Suggestion**: Turn these research topics into educational content.\n"
else:
output += "\nNo bookmarks yet. Save interesting content to fuel ideas.\n"
output += """
## Undeveloped Ideas
"""
ideas = get_undeveloped_ideas()
if ideas:
output += f"\nYou have {len(ideas)} undeveloped ideas:\n"
for idea in ideas[:count]:
output += f"- [{idea.get('priority', 'medium')}] {idea.get('idea', 'No content')}\n"
output += "\n**Suggestion**: Pick one high-priority idea and develop it today.\n"
else:
output += "\nNo undeveloped ideas in the queue.\n"
output += """
## Quick Prompts
1. "What's one thing I learned this week that others would find valuable?"
2. "What's a common mistake I see in my industry?"
3. "What question do I get asked most often?"
4. "What worked for me that's counterintuitive?"
5. "What do I wish I knew when I started?"
"""
return output
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Generate content ideas')
parser.add_argument('--pillar', '-p', help='Filter by content pillar')
parser.add_argument('--count', '-c', type=int, default=5, help='Number of ideas to show')
args = parser.parse_args()
print(generate_suggestions(args.pillar, args.count))
#!/usr/bin/env python3
"""
Idea to Draft Expander
Takes an idea ID and creates a draft scaffold with relevant context.
"""
import json
import argparse
from datetime import datetime
from pathlib import Path
BRAIN_ROOT = Path(__file__).parent.parent.parent
def load_jsonl(filepath):
"""Load JSONL file, skipping schema lines."""
items = []
if not filepath.exists():
return items
with open(filepath, 'r') as f:
for line in f:
line = line.strip()
if not line:
continue
try:
data = json.loads(line)
if '_schema' not in data:
items.append(data)
except json.JSONDecodeError:
continue
return items
def find_idea(idea_id):
"""Find an idea by ID or partial match."""
ideas = load_jsonl(BRAIN_ROOT / 'content' / 'ideas.jsonl')
for idea in ideas:
if idea.get('id') == idea_id:
return idea
# Partial match
if idea_id.lower() in idea.get('id', '').lower():
return idea
if idea_id.lower() in idea.get('idea', '').lower():
return idea
return None
def find_related_bookmarks(tags, pillar):
"""Find bookmarks related to the idea."""
bookmarks = load_jsonl(BRAIN_ROOT / 'knowledge' / 'bookmarks.jsonl')
related = []
for bm in bookmarks:
bm_tags = set(bm.get('tags', []))
bm_category = bm.get('category', '')
if tags and bm_tags.intersection(set(tags)):
related.append(bm)
elif pillar and bm_category == pillar:
related.append(bm)
return related[:5]
def find_similar_posts(pillar):
"""Find past posts in same pillar for reference."""
posts = load_jsonl(BRAIN_ROOT / 'content' / 'posts.jsonl')
similar = [p for p in posts if p.get('pillar') == pillar]
return similar[:3]
def generate_draft_scaffold(idea_id):
"""Generate a draft scaffold from an idea."""
idea = find_idea(idea_id)
if not idea:
return f"Error: Could not find idea matching '{idea_id}'"
pillar = idea.get('pillar', 'general')
tags = idea.get('tags', [])
related_bookmarks = find_related_bookmarks(tags, pillar)
similar_posts = find_similar_posts(pillar)
output = f"""
# Draft: {idea.get('idea', 'Untitled')}
## Metadata
```yaml
source_idea: {idea.get('id', 'unknown')}
pillar: {pillar}
created: {datetime.now().isoformat()}
status: draft
tags: {tags}
```
## Original Idea
```
{idea.get('idea', 'No content')}
```
Source: {idea.get('source', 'Unknown')}
Notes: {idea.get('notes', 'None')}
---
## Hook Options
<!-- Write 2-3 hook options -->
1. [Hook option 1]
2. [Hook option 2]
3. [Hook option 3]
---
## Main Points
### Point 1
[Expand here]
### Point 2
[Expand here]
### Point 3
[Expand here]
---
## Supporting Evidence
"""
if related_bookmarks:
output += "\n### From Your Research\n"
for bm in related_bookmarks:
output += f"- [{bm.get('title', 'Untitled')}]({bm.get('url', '#')})\n"
if bm.get('key_insights'):
output += f" Insight: {bm['key_insights'][0]}\n"
else:
output += "\nNo related bookmarks found. Consider researching this topic.\n"
output += """
---
## Reference: Similar Past Content
"""
if similar_posts:
for post in similar_posts:
output += f"- {post.get('type', 'post')}: {post.get('url', 'No URL')}\n"
else:
output += "\nNo similar past content found.\n"
output += """
---
## Call to Action
[What should the reader do?]
---
## Pre-publish Checklist
- [ ] Hook is compelling
- [ ] Main points are clear and valuable
- [ ] Voice matches brand (check identity/voice.md)
- [ ] CTA is clear
- [ ] Proofread
---
*Remember: Check identity/voice.md before finalizing!*
"""
return output
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Expand an idea into a draft')
parser.add_argument('idea_id', help='ID or partial match of the idea to expand')
args = parser.parse_args()
print(generate_draft_scaffold(args.idea_id))
#!/usr/bin/env python3
"""
Stale Contacts Finder
Identifies contacts that haven't been reached out to recently.
"""
import json
from datetime import datetime, timedelta
from pathlib import Path
BRAIN_ROOT = Path(__file__).parent.parent.parent
# Thresholds by circle (in days)
THRESHOLDS = {
'inner': 14, # 2 weeks
'active': 30, # 1 month
'network': 60, # 2 months
'dormant': 180 # 6 months (for potential reactivation)
}
def load_jsonl(filepath):
"""Load JSONL file, skipping schema lines."""
items = []
if not filepath.exists():
return items
with open(filepath, 'r') as f:
for line in f:
line = line.strip()
if not line:
continue
try:
data = json.loads(line)
if '_schema' not in data:
items.append(data)
except json.JSONDecodeError:
continue
return items
def days_since(date_str):
"""Calculate days since a date string."""
if not date_str:
return 999 # Very stale if no date
try:
date = datetime.fromisoformat(date_str.replace('Z', '+00:00'))
return (datetime.now(date.tzinfo) - date).days
except (ValueError, TypeError):
return 999
def find_stale_contacts():
"""Find contacts needing outreach."""
contacts = load_jsonl(BRAIN_ROOT / 'network' / 'contacts.jsonl')
stale = {
'urgent': [], # Way overdue
'due': [], # Due for contact
'coming_up': [] # Getting close
}
for contact in contacts:
circle = contact.get('circle', 'network')
threshold = THRESHOLDS.get(circle, 60)
days = days_since(contact.get('last_contact'))
contact_info = {
'name': contact.get('name', 'Unknown'),
'circle': circle,
'days_since': days,
'threshold': threshold,
'handle': contact.get('handle', ''),
'notes': contact.get('notes', '')[:100]
}
if days > threshold * 1.5:
stale['urgent'].append(contact_info)
elif days > threshold:
stale['due'].append(contact_info)
elif days > threshold * 0.75:
stale['coming_up'].append(contact_info)
return stale
def generate_report():
"""Generate stale contacts report."""
stale = find_stale_contacts()
output = f"""
# Stale Contacts Report
Generated: {datetime.now().isoformat()}
## Urgently Overdue ({len(stale['urgent'])})
"""
if stale['urgent']:
for c in sorted(stale['urgent'], key=lambda x: -x['days_since']):
output += f"- **{c['name']}** ({c['circle']}) - {c['days_since']} days since contact\n"
if c['handle']:
output += f" {c['handle']}\n"
else:
output += "None! You're on top of things.\n"
output += f"""
## Due for Contact ({len(stale['due'])})
"""
if stale['due']:
for c in sorted(stale['due'], key=lambda x: -x['days_since']):
output += f"- {c['name']} ({c['circle']}) - {c['days_since']} days\n"
else:
output += "None due right now.\n"
output += f"""
## Coming Up ({len(stale['coming_up'])})
"""
if stale['coming_up']:
for c in sorted(stale['coming_up'], key=lambda x: -x['days_since']):
output += f"- {c['name']} ({c['circle']}) - {c['days_since']} days (threshold: {c['threshold']})\n"
else:
output += "No contacts approaching threshold.\n"
output += """
## Suggested Actions
1. Send a quick "thinking of you" message to urgent contacts
2. Schedule calls with due inner-circle contacts
3. Engage with content from coming-up contacts
## Thresholds
- Inner circle: Every 2 weeks
- Active: Every month
- Network: Every 2 months
- Dormant: Quarterly check for reactivation
"""
return output
if __name__ == '__main__':
print(generate_report())
#!/usr/bin/env python3
"""
Weekly Review Generator
Compiles data from Digital Brain into a weekly review document.
"""
import json
import os
from datetime import datetime, timedelta
from pathlib import Path
# Get the digital brain root (parent of agents/)
BRAIN_ROOT = Path(__file__).parent.parent.parent
def load_jsonl(filepath):
"""Load JSONL file, skipping schema lines."""
items = []
if not filepath.exists():
return items
with open(filepath, 'r') as f:
for line in f:
line = line.strip()
if not line:
continue
try:
data = json.loads(line)
# Skip schema definition lines
if '_schema' not in data:
items.append(data)
except json.JSONDecodeError:
continue
return items
def get_week_range():
"""Get the start and end of the current week."""
today = datetime.now()
start = today - timedelta(days=today.weekday())
end = start + timedelta(days=6)
return start.strftime('%Y-%m-%d'), end.strftime('%Y-%m-%d')
def analyze_content(week_start):
"""Analyze content published this week."""
posts = load_jsonl(BRAIN_ROOT / 'content' / 'posts.jsonl')
ideas = load_jsonl(BRAIN_ROOT / 'content' / 'ideas.jsonl')
week_posts = [p for p in posts if p.get('published', '') >= week_start]
new_ideas = [i for i in ideas if i.get('created', '') >= week_start]
return {
'posts_published': len(week_posts),
'new_ideas': len(new_ideas),
'posts': week_posts
}
def analyze_network(week_start):
"""Analyze network activity this week."""
interactions = load_jsonl(BRAIN_ROOT / 'network' / 'interactions.jsonl')
week_interactions = [i for i in interactions if i.get('date', '') >= week_start]
return {
'interactions': len(week_interactions),
'details': week_interactions
}
def analyze_metrics():
"""Get latest metrics if available."""
metrics = load_jsonl(BRAIN_ROOT / 'operations' / 'metrics.jsonl')
if metrics:
return metrics[-1] # Most recent
return {}
def generate_review():
"""Generate the weekly review output."""
week_start, week_end = get_week_range()
content = analyze_content(week_start)
network = analyze_network(week_start)
metrics = analyze_metrics()
review = f"""
# Weekly Review: {week_start} to {week_end}
Generated: {datetime.now().isoformat()}
## Summary
### Content
- Posts published: {content['posts_published']}
- New ideas captured: {content['new_ideas']}
### Network
- Interactions logged: {network['interactions']}
### Latest Metrics
"""
if metrics:
audience = metrics.get('audience', {})
for key, value in audience.items():
review += f"- {key}: {value}\n"
else:
review += "- No metrics recorded yet\n"
review += """
## Action Items
1. [ ] Review content performance
2. [ ] Plan next week's content
3. [ ] Follow up on pending introductions
4. [ ] Update goals progress
5. [ ] Schedule key meetings
## Notes
[Add your reflections here]
"""
return review
if __name__ == '__main__':
print(generate_review())
Content Calendar
Publishing Schedule
Weekly Cadence
monday:
platform: "[PLACEHOLDER: e.g., Twitter]"
type: "[PLACEHOLDER: e.g., Educational thread]"
time: "[PLACEHOLDER: e.g., 9am EST]"
tuesday:
platform: "[PLACEHOLDER]"
type: "[PLACEHOLDER]"
time: "[PLACEHOLDER]"
wednesday:
platform: "[PLACEHOLDER]"
type: "[PLACEHOLDER]"
time: "[PLACEHOLDER]"
thursday:
platform: "[PLACEHOLDER]"
type: "[PLACEHOLDER]"
time: "[PLACEHOLDER]"
friday:
platform: "[PLACEHOLDER]"
type: "[PLACEHOLDER]"
time: "[PLACEHOLDER]"
weekend:
approach: "[PLACEHOLDER: e.g., Light engagement only, personal posts]"---
This Week
Week of [DATE]
| Day | Platform | Content | Status |
|---|---|---|---|
| Mon | `planned | ||
| Tue | |||
| Wed | |||
| Thu | |||
| Fri |
Theme/Focus: [PLACEHOLDER: What's the focus for this week]
---
Upcoming Content
Queued & Ready
<!-- Content ready to publish -->
- [ ] [PLACEHOLDER: Content title] - Platform - Target date
- [ ] [PLACEHOLDER]
In Development
<!-- Content being worked on -->
- [ ] [PLACEHOLDER: Content title] - Status - Notes
- [ ] [PLACEHOLDER]
Planned Series/Campaigns
<!-- Multi-part content or campaigns -->
- [ ] [PLACEHOLDER: Series name] - Parts: X - Status
- [ ] [PLACEHOLDER]
---
Content Batching
Batch Sessions
batch_day: "[PLACEHOLDER: e.g., Sunday]"
batch_duration: "[PLACEHOLDER: e.g., 2 hours]"
target_output: "[PLACEHOLDER: e.g., 5 posts for the week]"Current Batch Status
- Posts ready: [X/Y]
- Threads ready: [X/Y]
- Newsletter ready: [Yes/No]
---
Important Dates
Upcoming Events to Create Content For
- [DATE]: [PLACEHOLDER: Event/holiday/launch]
- [DATE]: [PLACEHOLDER]
Recurring Content
- Monthly: [PLACEHOLDER: e.g., Monthly learnings thread]
- Quarterly: [PLACEHOLDER: e.g., Goal review]
- Annually: [PLACEHOLDER: e.g., Year in review]
---
Notes
[PLACEHOLDER: Any notes about content strategy, experiments to try, etc.]
---
Last updated: [DATE]
Content Hub
Your content creation and management system.
Files in This Module
| File | Format | Purpose |
|---|---|---|
ideas.jsonl | JSONL | Raw content ideas (append-only) |
posts.jsonl | JSONL | Published content log |
calendar.md | Markdown | Content schedule |
drafts/ | Folder | Work-in-progress content |
templates/ | Folder | Reusable content formats |
engagement.jsonl | JSONL | Saved posts/threads for inspiration |
Workflows
Capture an Idea
# Append to ideas.jsonl with timestamp
{
"id": "idea_YYYYMMDD_HHMMSS",
"created": "ISO8601",
"idea": "content",
"source": "where it came from",
"pillar": "content pillar",
"status": "raw|developing|ready",
"priority": "high|medium|low"
}Content Creation Pipeline
1. ideas.jsonl (capture)
↓
2. drafts/draft_[topic].md (develop)
↓
3. Review against voice.md
↓
4. Publish
↓
5. posts.jsonl (archive with metrics)Weekly Content Review
1. Review ideas.jsonl - promote or archive stale ideas 2. Check calendar.md - plan next week 3. Review posts.jsonl - analyze what worked 4. Update engagement.jsonl - save inspiring content
Agent Instructions
<instructions> When working with content:
1. Capturing ideas: Always append to ideas.jsonl, never overwrite 2. Creating drafts: Use templates from templates/ as starting points 3. Writing content: MUST read identity/voice.md first 4. Publishing: Log to posts.jsonl with all metadata 5. Analysis: Reference posts.jsonl for performance patterns
Priority scoring:
- High: Timely, high-value, aligns with current goals
- Medium: Good idea, no urgency
- Low: Worth capturing, develop later
</instructions>
Content Metrics to Track
engagement_metrics:
- impressions
- likes
- comments
- reposts
- saves
- link_clicks
quality_indicators:
- comment_quality: "meaningful discussions vs. emoji reactions"
- share_context: "what people say when sharing"
- follower_conversion: "followers gained from post"{"_schema": "saved_content", "_version": "1.0", "_description": "Content from others that inspired you, engaged with, or want to reference. Great for understanding what resonates."}
{"id": "saved_001", "saved_at": "2024-01-01T00:00:00Z", "platform": "twitter|linkedin|other", "author": "[PLACEHOLDER: @handle or name]", "url": "[PLACEHOLDER: Link to content]", "content_summary": "[PLACEHOLDER: What the content was about]", "why_saved": "inspiration|reference|reply_to|collaboration|learning", "your_engagement": "[PLACEHOLDER: Did you reply? What did you say?]", "takeaways": "[PLACEHOLDER: What you learned or want to remember]", "tags": ["[tag1]", "[tag2]"]}
{"_schema": "content_idea", "_version": "1.0", "_description": "Append new ideas below this line. Never delete entries - mark as archived instead."}
{"id": "idea_example_001", "created": "2024-01-01T00:00:00Z", "idea": "[PLACEHOLDER: Your first content idea]", "source": "observation|conversation|reading|shower_thought", "pillar": "[PLACEHOLDER: Which content pillar]", "status": "raw", "priority": "medium", "notes": "[PLACEHOLDER: Additional context]", "tags": ["[tag1]", "[tag2]"]}
{"_schema": "published_post", "_version": "1.0", "_description": "Log of all published content with performance metrics. Append only."}
{"id": "post_example_001", "published": "2024-01-01T00:00:00Z", "platform": "twitter|linkedin|newsletter|blog", "type": "post|thread|article|video", "content": "[PLACEHOLDER: Full content or summary]", "url": "[PLACEHOLDER: Link to post]", "pillar": "[PLACEHOLDER: Content pillar]", "metrics": {"impressions": 0, "likes": 0, "comments": 0, "reposts": 0, "saves": 0}, "metrics_updated": "2024-01-01T00:00:00Z", "notes": "[PLACEHOLDER: What worked/didn't work]", "tags": ["[tag1]", "[tag2]"]}
LinkedIn Post Template
Metadata
topic: "[PLACEHOLDER]"
pillar: "[PLACEHOLDER: Content pillar]"
format: "story|lesson|hot_take|how_to|list"---
Hook (First 2-3 lines)
<!-- Must work before "see more" click -->
[PLACEHOLDER: Strong opening that makes them click "see more"]---
Body
Format: Story
The setup:
[PLACEHOLDER: Situation/context]
The challenge:
[PLACEHOLDER: What happened/the problem]
The turning point:
[PLACEHOLDER: What changed]
The lesson:
[PLACEHOLDER: What you learned]Format: Lesson/How-To
Here's how [PLACEHOLDER: outcome]:
1. [Step/Point]
[PLACEHOLDER: Brief explanation]
2. [Step/Point]
[PLACEHOLDER: Brief explanation]
3. [Step/Point]
[PLACEHOLDER: Brief explanation]
The key insight:
[PLACEHOLDER]Format: Hot Take
[PLACEHOLDER: Controversial statement]
Here's why:
[PLACEHOLDER: Supporting argument 1]
[PLACEHOLDER: Supporting argument 2]
[PLACEHOLDER: Nuance or caveat]---
Closing
[PLACEHOLDER: Summary or call to discussion]---
Engagement Hook
<!-- Encourage comments -->
[PLACEHOLDER: Question for the audience]
Examples:
- "What's your take?"
- "Have you experienced this?"
- "What would you add?"---
Hashtags (3-5 max)
#[PLACEHOLDER] #[PLACEHOLDER] #[PLACEHOLDER]---
Pre-publish Checklist
- [ ] Hook works in first 2-3 lines
- [ ] Uses line breaks for readability
- [ ] Value is professional but personal
- [ ] Ends with engagement prompt
- [ ] Voice matches brand (slightly more professional for LinkedIn)
- [ ] Not overly self-promotional
Newsletter Template
Metadata
issue_number: "[X]"
title: "[PLACEHOLDER]"
subtitle: "[PLACEHOLDER: One-liner preview]"
publish_date: "[DATE]"
pillar: "[PLACEHOLDER: Content pillar]"---
Subject Line Options
<!-- Test different subject lines --> 1. [PLACEHOLDER: Option 1] 2. [PLACEHOLDER: Option 2] 3. [PLACEHOLDER: Option 3]
Preview Text
[PLACEHOLDER: First 50-100 chars that show in email preview]---
Opening Hook
<!-- Personal, relatable, or intriguing opener -->
[PLACEHOLDER: 2-3 sentences that pull them in]---
Main Content
Section 1: [Topic]
[PLACEHOLDER: Main insight or story]Section 2: [Topic]
[PLACEHOLDER: Supporting point or framework]Section 3: [Topic] (optional)
[PLACEHOLDER: Additional value]---
Key Takeaway
<!-- The one thing they should remember -->
[PLACEHOLDER: Summarize the value in 1-2 sentences]---
Action Item
<!-- What can they do with this information? -->
[PLACEHOLDER: Specific, actionable next step]---
Closing
[PLACEHOLDER: Personal sign-off, what's coming next]---
Links & Resources
<!-- Everything mentioned in the newsletter -->
- PLACEHOLDER: Resource 1
- PLACEHOLDER: Resource 2
---
Pre-publish Checklist
- [ ] Subject line is compelling (would I open this?)
- [ ] Opening creates connection
- [ ] Value is clear and specific
- [ ] Formatting is mobile-friendly
- [ ] All links work
- [ ] CTA is clear
- [ ] Proofread for typos
- [ ] Voice matches brand (checked against voice.md)
Thread Template
Metadata
topic: "[PLACEHOLDER]"
pillar: "[PLACEHOLDER: Content pillar]"
target_platform: "twitter"
estimated_tweets: "[X]"---
1/ Hook
<!-- First tweet - must stop the scroll -->
[PLACEHOLDER: Controversial take, surprising stat, or curiosity gap]2/ Context
<!-- Set up the problem or situation -->
[PLACEHOLDER: Why should they care? What's the context?]3-7/ Main Points
<!-- Core value of the thread -->
Point 1
[PLACEHOLDER]Point 2
[PLACEHOLDER]Point 3
[PLACEHOLDER]Point 4 (optional)
[PLACEHOLDER]Point 5 (optional)
[PLACEHOLDER]8/ Takeaway
<!-- Summarize the key insight -->
[PLACEHOLDER: The one thing they should remember]9/ CTA
<!-- What should they do next? -->
[PLACEHOLDER: Follow, subscribe, reply, share, etc.]---
Pre-publish Checklist
- [ ] Hook is compelling (would I stop scrolling?)
- [ ] Each tweet stands alone but flows together
- [ ] Value is clear and actionable
- [ ] Matches my voice (checked against voice.md)
- [ ] No tweets over 280 characters
- [ ] CTA is clear but not pushy
Example: Content Creation Workflow
A complete walkthrough of using Digital Brain for content creation.
---
Scenario
You want to write a Twitter thread about "lessons from building in public."
---
Step 1: Agent Activates Skill
User Input: "Help me write a thread about lessons from building in public"
Agent Recognition:
- Trigger: "write a thread" → content creation
- Topic: "building in public" → likely matches brand pillars
- Action: Load Digital Brain skill
---
Step 2: Load Identity (Required)
Agent reads identity/voice.md:
# Extracted patterns:
formal_casual: 7/10 (fairly casual)
signature_phrases:
- "Here's the thing"
- "Let me break it down"
power_words:
- "ship", "iterate", "leverage"
avoid:
- "synergy", "circle back"
- excessive emojisAgent reads identity/brand.md:
# Confirms topic alignment:
content_pillars:
- building_in_public ✓ MATCH
- ai_agents
- founder_lessons
target_audience: "Early-stage technical founders"---
Step 3: Reference Past Success
Agent scans content/posts.jsonl:
// Found similar high-performing thread:
{
"type": "thread",
"pillar": "building_in_public",
"metrics": {"likes": 234, "reposts": 45},
"notes": "Story format worked well"
}Insight: Story-driven threads perform best for this pillar.
---
Step 4: Check Ideas Bank
Agent scans content/ideas.jsonl:
// Found relevant undeveloped idea:
{
"idea": "Thread on the emotional rollercoaster of public building",
"status": "raw",
"priority": "high"
}Decision: Can incorporate this angle into the thread.
---
Step 5: Generate Draft
Agent uses content/templates/thread.md as scaffold:
## 1/ Hook
Unpopular opinion: Building in public isn't about the wins.
Here's the thing - it's about the messy middle.
Let me break it down 🧵
## 2/ Context
I've been building in public for 18 months.
Here's what I wish someone told me on day 1:
## 3-7/ Main Points
[5 specific lessons with stories]
## 8/ Takeaway
The compound effect of transparency beats any marketing strategy.
## 9/ CTA
Follow for more founder lessons as I ship @handleVoice Alignment Check:
- ✓ Uses "Here's the thing" (signature phrase)
- ✓ Uses "Let me break it down" (signature phrase)
- ✓ Casual but substantive tone (7/10)
- ✓ No corporate jargon
- ⚠️ Limited emoji (one 🧵 - acceptable)
---
Step 6: User Feedback & Iteration
User: "Can you make point 3 about the fear of judgment?"
Agent: 1. Keeps same voice/structure 2. Rewrites point 3 with fear angle 3. Maintains thread flow
---
Step 7: Log the Idea (If Not Publishing)
If user saves for later, agent appends to content/ideas.jsonl:
{
"id": "idea_20241229_160000",
"created": "2024-12-29T16:00:00Z",
"idea": "Thread: 5 lessons from building in public (fear, wins, community...)",
"source": "developed_draft",
"pillar": "building_in_public",
"status": "ready",
"priority": "high",
"notes": "Draft complete, reviewed voice alignment",
"tags": ["thread", "building_in_public", "founder_lessons"]
}---
Step 8: Post-Publish Logging
After user publishes, agent appends to content/posts.jsonl:
{
"id": "post_20241229_180000",
"published": "2024-12-29T18:00:00Z",
"platform": "twitter",
"type": "thread",
"content": "Unpopular opinion: Building in public isn't about the wins...",
"url": "https://twitter.com/user/status/123456789",
"pillar": "building_in_public",
"metrics": {
"impressions": 0,
"likes": 0,
"comments": 0,
"reposts": 0
},
"metrics_updated": "2024-12-29T18:00:00Z",
"notes": "Story-driven format, fear angle resonated in drafting",
"tags": ["thread", "building_in_public"]
}---
Files Accessed
| File | Purpose | Tokens (~) |
|---|---|---|
SKILL.md | Routing | 50 |
identity/voice.md | Voice patterns | 200 |
identity/brand.md | Topic validation | 150 |
content/posts.jsonl | Past performance | 100 |
content/ideas.jsonl | Existing ideas | 50 |
content/templates/thread.md | Structure | 100 |
Total: ~650 tokens vs loading entire brain (~5000 tokens)
---
Key Takeaways
1. Voice First: Always loaded before drafting 2. Progressive Loading: Only relevant modules accessed 3. Pattern Matching: Past success informs new content 4. Full Pipeline: Idea → Draft → Publish → Log 5. Append-Only: Ideas and posts logged, never deleted
Example: Meeting Preparation Workflow
A complete walkthrough of using Digital Brain for meeting preparation.
---
Scenario
You have a call with "Sarah Chen" in 30 minutes and need a quick brief.
---
Step 1: Agent Activates Skill
User Input: "Prepare me for my call with Sarah Chen"
Agent Recognition:
- Trigger: "prepare for" + person name → meeting prep
- Action: Load Digital Brain skill, network module
---
Step 2: Contact Lookup
Agent searches network/contacts.jsonl for "Sarah Chen":
{
"id": "contact_sarahchen",
"name": "Sarah Chen",
"handle": "@sarahchen_ai",
"company": "AI Ventures",
"role": "Partner",
"circle": "active",
"how_met": "She reached out after my thread on agent systems",
"relationship": "potential_investor",
"topics": ["ai_agents", "investing", "founder_market_fit"],
"can_help_with": ["Funding intros", "GTM strategy advice"],
"you_can_help_with": ["Technical due diligence", "Agent architecture insights"],
"notes": "Very technical for a VC. Former ML engineer at Google. Values depth over polish.",
"last_contact": "2024-12-15T00:00:00Z",
"links": {
"twitter": "https://twitter.com/sarahchen_ai",
"linkedin": "https://linkedin.com/in/sarahchen"
}
}---
Step 3: Interaction History
Agent filters network/interactions.jsonl by contact_id:
// Most recent interaction:
{
"id": "int_20241215_100000",
"date": "2024-12-15T10:00:00Z",
"contact_id": "contact_sarahchen",
"type": "call",
"context": "Initial intro call. She's interested in our agent framework approach.",
"key_points": [
"She liked our context engineering approach",
"Asked about moat - I explained skill composability",
"She mentioned her portfolio company BuildAI might need our help"
],
"follow_ups": [
"Send deck with technical architecture",
"Intro to BuildAI team"
],
"sentiment": "positive"
}
// Earlier interaction:
{
"id": "int_20241201_140000",
"date": "2024-12-01T14:00:00Z",
"contact_id": "contact_sarahchen",
"type": "dm",
"context": "She DMed after my agent systems thread",
"key_points": ["Impressed by technical depth", "Asked about investment stage"],
"follow_ups": ["Schedule intro call"],
"sentiment": "positive"
}---
Step 4: Check Pending Items
Agent scans operations/todos.md for Sarah-related items:
### Waiting On
| Task | Waiting On | Since | Follow Up |
|------|------------|-------|-----------|
| BuildAI intro | Sarah Chen | 2024-12-15 | 2024-12-29 |
### P1 - This Week
- [ ] Send technical deck to Sarah ChenInsight: Follow-up items are overdue!
---
Step 5: Generate Brief
Agent compiles contextual brief:
# Meeting Brief: Sarah Chen
**When**: Today, [TIME]
**Who**: Sarah Chen, Partner @ AI Ventures
**Relationship**: Potential Investor (active circle)
**Days since last contact**: 14
---
## Quick Context
- Former ML engineer at Google (technical background)
- Reached out after your agent systems thread
- Values depth over polish
---
## Last Conversation (Dec 15)
- Initial intro call - positive sentiment
- She liked context engineering approach
- Asked about moat → explained skill composability
- Mentioned BuildAI (portfolio company) might need help
---
## Pending Follow-ups ⚠️
1. **Send technical deck** - Still pending (P1)
2. **BuildAI intro** - Waiting on her, follow up today
---
## Her Interests
- Agent architecture
- Context engineering
- Technical due diligence
---
## Value Exchange
- **She can help**: Funding intros, GTM strategy
- **You can help**: Technical DD, agent architecture
---
## Suggested Talking Points
1. Apologize for delayed deck, offer to walk through live
2. Ask about BuildAI intro status
3. Share recent progress on [relevant feature]
4. Ask about her investment thesis timeline
---
## Links
- Twitter: @sarahchen_ai
- LinkedIn: linkedin.com/in/sarahchen---
Step 6: Post-Meeting Logging
After the call, agent helps log to network/interactions.jsonl:
User: "Just finished with Sarah. She's moving forward with intro to BuildAI and wants to see the deck by Friday."
Agent appends:
{
"id": "int_20241229_143000",
"date": "2024-12-29T14:30:00Z",
"contact_id": "contact_sarahchen",
"type": "call",
"context": "Follow-up call. Positive momentum on both fronts.",
"key_points": [
"She's proceeding with BuildAI intro",
"Wants technical deck by Friday",
"Mentioned Series A timeline is Q1"
],
"follow_ups": [
"Send deck by Friday Dec 31",
"Expect BuildAI intro next week"
],
"sentiment": "positive"
}Agent updates operations/todos.md:
### P0 - Must Do Today
- [ ] Send technical deck to Sarah Chen (due: Friday)
### Waiting On
| Task | Waiting On | Since | Follow Up |
|------|------------|-------|-----------|
| BuildAI intro | Sarah Chen | 2024-12-29 | 2025-01-05 |Agent updates contact's last_contact:
{
"id": "contact_sarahchen",
...
"last_contact": "2024-12-29T14:30:00Z"
}---
Files Accessed
| File | Purpose | Tokens (~) |
|---|---|---|
SKILL.md | Routing | 50 |
network/NETWORK.md | Module instructions | 60 |
network/contacts.jsonl | Contact lookup | 80 |
network/interactions.jsonl | History | 150 |
operations/todos.md | Pending items | 50 |
Total: ~390 tokens
---
Key Takeaways
1. Context Assembly: Agent pulls from multiple sources 2. Actionable Output: Brief highlights what to discuss 3. Follow-up Tracking: Pending items surfaced proactively 4. Complete Loop: Meeting → Log → Update todos → Update contact 5. Relationship Intelligence: Notes inform meeting approach
How Agent Skills for Context Engineering Built Digital Brain
This document demonstrates how the Agent Skills for Context Engineering collection was used by a Claude Code agent to design and build a production-ready personal knowledge management system.
---
Executive Summary
Digital Brain wasn't built from scratch intuition—it was systematically designed by applying 10 context engineering skills. Each architectural decision traces back to specific principles from the skills collection.
Result: A scalable personal OS with:
- ~650 tokens per content task (vs ~5000 without optimization)
- 6 isolated modules preventing context pollution
- 4 automation scripts following tool design principles
- Progressive disclosure at every layer
---
Skill-by-Skill Application
1. Context Fundamentals → Core Architecture
Skill Teaching:
"Context is a finite resource with diminishing marginal returns—every token depletes the attention budget."
Applied in Digital Brain:
| Principle | Implementation |
|---|---|
| Attention budget | 6 modules load independently, not all at once |
| Progressive disclosure | L1 (SKILL.md) → L2 (MODULE.md) → L3 (data files) |
| Right altitude | SKILL.md gives overview; modules give specifics |
| Position awareness | Critical instructions at top of each file |
Specific Design Decision:
digital-brain/
├── SKILL.md # L1: Always loaded (~50 tokens)
├── identity/
│ ├── IDENTITY.md # L2: Loaded when content task (~80 tokens)
│ └── voice.md # L3: Loaded when writing (~200 tokens)The 3-level hierarchy directly implements the skill's "hybrid loading strategy"—stable metadata pre-loaded, dynamic content just-in-time.
---
2. Context Optimization → Module Separation
Skill Teaching:
"Context quality matters more than quantity. Optimization preserves signal while reducing noise."
Applied in Digital Brain:
| Technique | Implementation |
|---|---|
| Context partitioning | 6 modules (identity, content, knowledge, network, operations, agents) |
| Cache-friendly ordering | Stable configs (.yaml) before dynamic logs (.jsonl) |
| Selective preservation | Only relevant module loads for each task type |
Specific Design Decision:
Content creation task loads:
identity/✓ (voice patterns)content/✓ (templates, past posts)knowledge/✗ (not needed)network/✗ (not needed)operations/✗ (not needed)
Token Savings: 650 tokens vs 5000+ if everything loaded
---
3. Context Compression → JSONL Design
Skill Teaching:
"Structure forces preservation: Dedicated sections act as mandatory checkboxes preventing silent information loss."
Applied in Digital Brain:
| Principle | Implementation |
|---|---|
| Structured summaries | Every JSONL entry has consistent schema |
| Artifact trail | posts.jsonl tracks all published content with metrics |
| Mandatory sections | Schema line documents structure: {"_schema": "...", "_version": "..."} |
Specific Design Decision:
Every JSONL file starts with schema documentation:
{"_schema": "contact", "_version": "1.0", "_description": "Personal contact database..."}
{"id": "contact_001", "name": "...", "last_contact": "..."}This ensures agents always understand the structure—implementing the skill's "structure forces preservation" principle.
---
4. Context Degradation → Mitigation Strategies
Skill Teaching:
"Lost-in-middle phenomenon: U-shaped attention curves where beginning/end receive 10-40% higher recall accuracy than middle."
Applied in Digital Brain:
| Risk | Mitigation |
|---|---|
| Lost-in-middle | Critical voice patterns at TOP of voice.md |
| Context poisoning | Append-only JSONL prevents error propagation |
| Context confusion | One source of truth per domain |
| Context distraction | Module separation prevents irrelevant content |
Specific Design Decision:
The skill's "four-bucket approach" directly shaped Digital Brain:
| Bucket | Implementation |
|---|---|
| Write | All data in external files, not inline |
| Select | Module-based filtering (only load relevant module) |
| Compress | JSONL streaming (read line-by-line, not full parse) |
| Isolate | 6 isolated modules |
---
5. Memory Systems → Data Architecture
Skill Teaching:
"Match architecture complexity to query requirements (file systems for simple needs; graphs for relationship reasoning)."
Applied in Digital Brain:
| Memory Layer | Implementation |
|---|---|
| Working memory | Current conversation context |
| Short-term | Session notes in operations/todos.md |
| Long-term | Persistent JSONL files across sessions |
| Entity memory | network/contacts.jsonl with relationships |
Specific Design Decision:
The skill recommends file systems for "simple needs"—Digital Brain uses exactly this:
# No database needed
# No vector store needed
# File system provides:
- Natural persistence
- Git-friendly versioning
- Agent-readable formats
- Zero dependenciesThe skill's "temporal validity" principle is implemented via last_contact timestamps in contacts and metrics_updated in posts.
---
6. Evaluation → Testing Approach
Skill Teaching:
"Outcome-focused evaluation: Agents reach goals through diverse valid paths; assess results, not specific steps."
Applied in Digital Brain:
| Principle | Implementation |
|---|---|
| Outcome focus | Examples show expected OUTPUT, not exact steps |
| Multi-dimensional | Content workflow checks voice, topic, format |
| Stratified testing | Simple (lookup) → Complex (weekly review) workflows |
Specific Design Decision:
The examples/ folder demonstrates outcome-focused evaluation:
# examples/content-workflow.md
**Input**: "Help me write a thread about AI agents"
**Expected Output**:
- Draft matches voice.md patterns
- Topic aligns with brand.md pillars
- Format follows templates/thread.md structureNot prescribing exact steps—evaluating the outcome.
---
7. Advanced Evaluation → Quality Checks
Skill Teaching:
"Well-defined rubrics reduce evaluation variance 40-60%."
Applied in Digital Brain:
| Technique | Implementation |
|---|---|
| Defined rubrics | Voice attributes rated 1-10 in voice.md |
| Explicit criteria | Checklists in every template |
| Confidence signals | Priority levels (P0-P3) for todos |
Specific Design Decision:
Every content template includes a quality checklist:
## Pre-publish Checklist
- [ ] Hook is compelling (would I stop scrolling?)
- [ ] Each tweet stands alone but flows together
- [ ] Value is clear and actionable
- [ ] Matches my voice (checked against voice.md)
- [ ] No tweets over 280 characters
- [ ] CTA is clear but not pushyThis is a rubric—reducing evaluation variance per the skill's teaching.
---
8. Multi-Agent Patterns → Module Isolation
Skill Teaching:
"Sub-agents exist primarily to isolate context, not to anthropomorphize roles."
Applied in Digital Brain:
| Pattern | Implementation |
|---|---|
| Context isolation | Each module is a "sub-agent context" |
| Supervisor pattern | SKILL.md routes to appropriate module |
| Specialization | Each module optimized for its domain |
Specific Design Decision:
While Digital Brain doesn't spawn literal sub-agents, it implements the same principle:
SKILL.md (supervisor/router)
↓ routes to
identity/IDENTITY.md (specialist context)
content/CONTENT.md (specialist context)
network/NETWORK.md (specialist context)
...The skill warns about "telephone game problem"—Digital Brain avoids this by having agents read source files directly, not summaries of summaries.
---
9. Project Development → Build Methodology
Skill Teaching:
"Validate before automating: Manual prototyping prevents wasted development."
Applied in Digital Brain:
| Principle | Implementation |
|---|---|
| Task-model fit | Personal knowledge management is LLM-suitable |
| Pipeline architecture | Ideas → Drafts → Posts (staged workflow) |
| File system state | Folders track progress naturally |
| Structured output | Templates enforce consistent formats |
Specific Design Decision:
The skill's "LLM suitability matrix" confirms Digital Brain's fit:
| Strength | Digital Brain Task |
|---|---|
| Synthesis | Generating content from voice patterns |
| Subjective judgment | Prioritizing content ideas |
| Natural output | Writing in user's voice |
| Batch processing | Weekly review across modules |
| Domain knowledge | Applying voice/brand context |
---
10. Tool Design → Automation Scripts
Skill Teaching:
"Consolidation over fragmentation: Bundle related workflows into comprehensive tools."
Applied in Digital Brain:
| Principle | Implementation |
|---|---|
| Clear descriptions | Each script has docstring explaining purpose |
| Actionable output | Scripts return markdown agents can use |
| Minimal collection | 4 scripts, not 20 micro-tools |
| Verb-noun naming | weekly_review.py, content_ideas.py |
Specific Design Decision:
The skill's evidence showed "reducing from 17 specialized tools to 2 primitive tools achieved 3.5× faster execution."
Digital Brain follows this:
# NOT: separate tools for each step
# get_ideas.py, filter_ideas.py, score_ideas.py, format_ideas.py
# YES: consolidated comprehensive tool
# content_ideas.py - does all of the above4 comprehensive scripts vs potential 15+ micro-tools.
---
Cross-Skill Synergies
Token Efficiency Chain
Context Fundamentals (attention budget)
→ Context Optimization (module separation)
→ Context Compression (JSONL streaming)
→ Context Degradation (mitigation)Result: 87% token reduction per task
Quality Assurance Chain
Evaluation (outcome focus)
→ Advanced Evaluation (rubrics)
→ Tool Design (clear outputs)Result: Templates with built-in quality checks
Architecture Chain
Memory Systems (file-based)
→ Multi-Agent Patterns (isolation)
→ Project Development (staged pipelines)Result: 6 isolated modules with clear data flow
---
Quantified Impact
| Metric | Without Skills | With Skills | Improvement |
|---|---|---|---|
| Tokens per content task | ~5000 | ~650 | 87% reduction |
| Module files touched | All 45 | 5-8 relevant | 82% reduction |
| Context pollution risk | High | Isolated | Eliminated |
| Automation scripts | 15+ micro | 4 comprehensive | 73% reduction |
| Schema consistency | Ad-hoc | Enforced | 100% coverage |
---
How Skills Will Continue to Be Used
Runtime Usage
When agents use Digital Brain, skills guide behavior:
1. Content Creation
- Context Fundamentals → Load only identity module
- Memory Systems → Retrieve from posts.jsonl for patterns
- Evaluation → Check against voice.md rubric
2. Meeting Prep
- Multi-Agent Patterns → Isolate to network module
- Context Degradation → Pull only relevant contact
- Tool Design → Output structured brief
3. Weekly Review
- Context Compression → Summarize week's activity
- Advanced Evaluation → Score against goals.yaml
- Project Development → Generate actionable output
Extension Development
Adding new features should apply:
1. New Module: Context Fundamentals (progressive disclosure) 2. New Script: Tool Design (consolidation principle) 3. New Template: Evaluation (outcome-focused) 4. New Data File: Memory Systems (appropriate layer)
---
Conclusion
Digital Brain demonstrates that the Agent Skills for Context Engineering collection isn't theoretical—it's a practical framework for building production AI systems.
Every architectural decision traces to a specific skill principle.
This is context engineering in action: not just prompting better, but designing systems that work with—not against—how language models process information.
---
Learn More
- Skills Collection: github.com/muratcankoylan/Agent-Skills-for-Context-Engineering
- Digital Brain: github.com/muratcankoylan/digital-brain-skill
---
This document itself demonstrates context engineering: structured sections, clear headings, tables for quick scanning, and progressive detail—all principles from the skills collection.
Bio Variants
Pre-written bios for different platforms and contexts.
---
Twitter/X Bio (160 chars)
[PLACEHOLDER: Your Twitter bio]LinkedIn Headline (120 chars)
[PLACEHOLDER: Your LinkedIn headline]LinkedIn About Section
[PLACEHOLDER: Your LinkedIn about section - can be longer]Newsletter/Substack Bio
[PLACEHOLDER: 2-3 sentences for newsletter]Speaker Bio (Short - 50 words)
[PLACEHOLDER: For conference programs, short intros]Speaker Bio (Long - 150 words)
[PLACEHOLDER: For detailed speaker pages]Podcast Guest Bio
[PLACEHOLDER: What hosts should read when introducing you]Press/Media Bio
[PLACEHOLDER: Formal bio for press releases]Casual Intro
[PLACEHOLDER: How you introduce yourself at casual events]
"Hey, I'm [Name]. I [one sentence about what you do]."Professional Intro
[PLACEHOLDER: For formal settings]---
Bio Components
Credentials Block
[PLACEHOLDER: Your key credentials/achievements to mix and match]
- [Credential 1]
- [Credential 2]
- [Credential 3]Personal Touch Block
[PLACEHOLDER: Human elements - hobbies, location, fun facts]
- [Personal detail 1]
- [Personal detail 2]CTA Block
[PLACEHOLDER: Calls to action for different contexts]
- Newsletter: "Subscribe at [link]"
- DMs: "DMs open for [topic]"
- Booking: "Book a call at [link]"---
Platform Links
website: "[PLACEHOLDER]"
twitter: "[PLACEHOLDER]"
linkedin: "[PLACEHOLDER]"
newsletter: "[PLACEHOLDER]"
github: "[PLACEHOLDER]"
youtube: "[PLACEHOLDER]"
calendar: "[PLACEHOLDER: Booking link]"---
Last updated: [DATE]
Personal Brand Strategy
Your positioning, audience, and strategic narrative.
---
Brand Positioning
One-Liner
<!-- How you describe yourself in one sentence -->
[PLACEHOLDER: e.g., "I help technical founders build in public and grow their audience."]Elevator Pitch (30 seconds)
[PLACEHOLDER: 2-3 sentence expanded version]Origin Story
<!-- Your narrative arc - where you came from, pivotal moments, where you're going -->
[PLACEHOLDER: Write your founder/creator story]---
Target Audience
Primary Audience
who: "[PLACEHOLDER: e.g., Early-stage technical founders]"
pain_points:
- "[PLACEHOLDER: e.g., Don't know how to market themselves]"
- "[PLACEHOLDER]"
- "[PLACEHOLDER]"
aspirations:
- "[PLACEHOLDER: e.g., Build a personal brand that attracts investors/talent]"
- "[PLACEHOLDER]"
where_they_hang_out:
- "[PLACEHOLDER: e.g., Twitter, Hacker News, specific Discords]"
- "[PLACEHOLDER]"Secondary Audiences
- segment: "[PLACEHOLDER: e.g., Aspiring founders]"
relevance: "[PLACEHOLDER: How you serve them]"
- segment: "[PLACEHOLDER]"
relevance: "[PLACEHOLDER]"---
Content Pillars
Primary Topics (80% of content)
<!-- Topics you're known for and have authority in -->
| Pillar | Description | Example Angles |
|---|---|---|
[PLACEHOLDER: e.g., Building in Public] | [Description] | [Example topics] |
[PLACEHOLDER: e.g., AI/Agents] | [Description] | [Example topics] |
[PLACEHOLDER] | [Description] | [Example topics] |
Secondary Topics (20% of content)
<!-- Adjacent topics that round out your brand -->
- [PLACEHOLDER: e.g., Productivity/Systems]
- [PLACEHOLDER: e.g., Founder mental health]
- [PLACEHOLDER]Off-Limits Topics
<!-- Topics you deliberately avoid -->
- [PLACEHOLDER: e.g., Politics]
- [PLACEHOLDER: e.g., Competitors by name]
- [PLACEHOLDER]---
Unique Value Proposition
What Makes You Different
[PLACEHOLDER: Your unique combination of skills/experience/perspective]Credibility Markers
achievements:
- "[PLACEHOLDER: e.g., Built X to $Y ARR]"
- "[PLACEHOLDER: e.g., Z followers across platforms]"
- "[PLACEHOLDER]"
experience:
- "[PLACEHOLDER: e.g., 10 years in industry]"
- "[PLACEHOLDER]"
social_proof:
- "[PLACEHOLDER: e.g., Featured in...]"
- "[PLACEHOLDER: e.g., Advised companies like...]"---
Brand Voice Alignment
Emotional Territory
<!-- How you want people to feel after engaging with your content -->
[PLACEHOLDER: e.g., "Inspired to take action, equipped with practical knowledge, part of a community"]Brand Personality
if_brand_were_a_person:
age: "[PLACEHOLDER]"
style: "[PLACEHOLDER: e.g., Smart casual, approachable]"
conversation_style: "[PLACEHOLDER: e.g., Like talking to a smart friend]"
energy: "[PLACEHOLDER: e.g., High energy but not manic]"---
Competitive Positioning
Similar Voices (Inspiration)
- [PLACEHOLDER: e.g., @name - what you like about their approach]
- [PLACEHOLDER]Differentiation
[PLACEHOLDER: How you're different from similar creators/founders]---
Growth Strategy
Current Focus
[PLACEHOLDER: e.g., Growing Twitter to 50k, launching newsletter]Platform Priority
primary: "[PLACEHOLDER: e.g., Twitter/X]"
secondary: "[PLACEHOLDER: e.g., LinkedIn]"
experimenting: "[PLACEHOLDER: e.g., YouTube]"Key Metrics
north_star: "[PLACEHOLDER: e.g., Newsletter subscribers]"
leading_indicators:
- "[PLACEHOLDER: e.g., Engagement rate]"
- "[PLACEHOLDER: e.g., Profile visits]"---
Last updated: [DATE]
Identity Module
Your digital identity foundation. This module defines who you are, how you communicate, and what you stand for.
Files in This Module
| File | Purpose |
|---|---|
voice.md | Tone, style, writing patterns |
brand.md | Positioning, topics, audience |
values.yaml | Core beliefs and principles |
bio-variants.md | Different bio lengths for platforms |
prompts/ | Reusable prompts for content generation |
When to Use
- Writing any content: Read
voice.mdfirst - New platform profile: Check
bio-variants.md - Strategic decisions: Reference
values.yaml - Content topics: Consult
brand.mdfor positioning
Agent Instructions
<instructions> When creating content for the user: 1. ALWAYS read voice.md before drafting 2. Match the energy level, vocabulary, and structural patterns 3. Avoid words/phrases listed in "never use" section 4. Incorporate signature phrases naturally 5. Check brand.md for topic relevance </instructions>
Voice Quick Reference
For detailed voice guidelines, see voice.md.
Key elements agents should internalize:
- Communication style (formal/casual spectrum)
- Signature phrases and vocabulary
- Structural patterns (post formats, hooks)
- Topics to emphasize vs avoid
<?xml version="1.0" encoding="UTF-8"?>
<prompt name="content-generation" version="1.0">
<description>
Master prompt for generating content in user's authentic voice.
Load voice.md and brand.md before using.
</description>
<instructions>
<context>
You are writing as {{USER_NAME}}, a {{USER_DESCRIPTION}}.
Before generating ANY content:
1. Review the voice profile in identity/voice.md
2. Check brand positioning in identity/brand.md
3. Reference recent successful posts if available
</context>
<voice_guidelines>
<formal_casual_level>{{VOICE_LEVEL}}</formal_casual_level>
<signature_phrases>
<!-- Populated from voice.md -->
</signature_phrases>
<avoid>
<!-- Words/phrases to never use -->
</avoid>
</voice_guidelines>
<output_requirements>
<format>{{CONTENT_FORMAT}}</format>
<platform>{{TARGET_PLATFORM}}</platform>
<length>{{TARGET_LENGTH}}</length>
<include_cta>{{INCLUDE_CTA}}</include_cta>
</output_requirements>
<quality_checks>
- Does this sound like the user's authentic voice?
- Is it aligned with their content pillars?
- Does it provide value to their target audience?
- Is the tone appropriate for the platform?
</quality_checks>
</instructions>
<examples>
<!-- Agent should pull examples from content/posts.jsonl -->
</examples>
</prompt>
<?xml version="1.0" encoding="UTF-8"?>
<prompt name="reply-generator" version="1.0">
<description>
Generate authentic replies to comments, DMs, or mentions.
Maintains voice while being contextually appropriate.
</description>
<instructions>
<context>
You are replying as {{USER_NAME}} to a {{CONTEXT_TYPE}}.
Original message/post being replied to:
<original>{{ORIGINAL_CONTENT}}</original>
Relationship context (if known):
<relationship>{{RELATIONSHIP_CONTEXT}}</relationship>
</context>
<reply_principles>
- Match the energy of the original (if positive, be positive)
- Add value - don't just acknowledge
- Be concise on social, more detailed in DMs
- If disagreeing, be respectful and constructive
- Reference shared context when appropriate
</reply_principles>
<tone_calibration>
<public_reply>Slightly more polished, brand-aware</public_reply>
<dm_reply>More casual, direct, personal</dm_reply>
<comment_reply>Concise, appreciative, engaging</comment_reply>
</tone_calibration>
<output>
Provide 2-3 reply options:
1. Standard reply
2. More casual/playful version
3. If appropriate, a version that extends the conversation
</output>
</instructions>
</prompt>
# Core Values & Principles
# These guide decision-making and content creation
core_values:
- name: "[PLACEHOLDER: e.g., Transparency]"
description: "[PLACEHOLDER: What this means to you]"
in_practice: "[PLACEHOLDER: How this shows up in your work/content]"
- name: "[PLACEHOLDER: e.g., Ownership]"
description: "[PLACEHOLDER]"
in_practice: "[PLACEHOLDER]"
- name: "[PLACEHOLDER: e.g., Continuous Learning]"
description: "[PLACEHOLDER]"
in_practice: "[PLACEHOLDER]"
- name: "[PLACEHOLDER]"
description: "[PLACEHOLDER]"
in_practice: "[PLACEHOLDER]"
beliefs:
# Strong opinions you hold
- "[PLACEHOLDER: e.g., The best marketing is building great products]"
- "[PLACEHOLDER: e.g., AI will augment, not replace, human creativity]"
- "[PLACEHOLDER]"
- "[PLACEHOLDER]"
contrarian_views:
# Views that differ from mainstream in your industry
- view: "[PLACEHOLDER: e.g., You don't need VC funding to build a great company]"
reasoning: "[PLACEHOLDER: Why you believe this]"
- view: "[PLACEHOLDER]"
reasoning: "[PLACEHOLDER]"
non_negotiables:
# Lines you won't cross
- "[PLACEHOLDER: e.g., Won't promote products I haven't used]"
- "[PLACEHOLDER: e.g., Won't engage in public negativity about individuals]"
- "[PLACEHOLDER]"
principles:
content_creation:
- "[PLACEHOLDER: e.g., Value over virality]"
- "[PLACEHOLDER: e.g., Share learnings, not just wins]"
- "[PLACEHOLDER]"
business:
- "[PLACEHOLDER: e.g., Customer success is company success]"
- "[PLACEHOLDER]"
relationships:
- "[PLACEHOLDER: e.g., Give before you ask]"
- "[PLACEHOLDER: e.g., Be genuinely helpful]"
- "[PLACEHOLDER]"
decision_framework:
# How you make decisions
when_uncertain: "[PLACEHOLDER: e.g., Bias toward action, iterate fast]"
priorities: "[PLACEHOLDER: e.g., Impact > Revenue > Growth]"
tradeoffs: "[PLACEHOLDER: e.g., Long-term reputation over short-term gains]"
Voice & Tone Guide
Your authentic voice captured for consistent communication across all platforms.
---
Core Voice Profile
Personality Snapshot
<!-- Describe your communication personality in 2-3 sentences -->
[PLACEHOLDER: e.g., "Direct and energetic with a bias toward action. I blend technical depth with accessible explanations. Optimistic but grounded in reality."]Voice Attributes (Rate 1-10)
| Attribute | Level | Notes |
|---|---|---|
| Formal ←→ Casual | [1-10] | <!-- e.g., 7 = fairly casual --> |
| Serious ←→ Playful | [1-10] | |
| Technical ←→ Simple | [1-10] | |
| Reserved ←→ Expressive | [1-10] | |
| Humble ←→ Confident | [1-10] |
---
Writing Patterns
Sentence Structure
<!-- How do you typically structure sentences? -->
[PLACEHOLDER: e.g., "Short punchy sentences. Rarely compound. One idea per line. Heavy use of line breaks for emphasis."]Paragraph Style
[PLACEHOLDER: e.g., "2-3 sentences max per paragraph. White space is your friend. Lists when explaining steps."]Hook Patterns
<!-- How do you typically open posts/content? -->
Examples:
- [PLACEHOLDER: e.g., "Hot take opener: 'Unpopular opinion: X'"]
- [PLACEHOLDER: e.g., "Story lead: 'Last week I...'"]
- [PLACEHOLDER: e.g., "Question hook: 'Ever noticed how...?'"]---
Vocabulary
Signature Phrases
<!-- Words/phrases you use frequently that feel "you" -->
phrases:
- "[PLACEHOLDER: e.g., 'Here's the thing']"
- "[PLACEHOLDER: e.g., 'Let me break it down']"
- "[PLACEHOLDER: e.g., 'The real question is']"Power Words
<!-- Words you gravitate toward -->
use_often:
- "[PLACEHOLDER: e.g., 'leverage', 'ship', 'iterate']"
- "[PLACEHOLDER]"
- "[PLACEHOLDER]"Never Use
<!-- Words/phrases that don't sound like you -->
avoid:
- "[PLACEHOLDER: e.g., 'synergy', 'circle back']"
- "[PLACEHOLDER: e.g., 'utilize' (use 'use' instead)]"
- "[PLACEHOLDER: e.g., excessive emojis]"---
Platform Adaptations
Twitter/X
- Character constraints: lean even shorter
- [PLACEHOLDER: Platform-specific notes]- Slightly more professional
- [PLACEHOLDER: Platform-specific notes]Long-form (Blog/Newsletter)
- Can expand on ideas
- [PLACEHOLDER: Platform-specific notes]---
Content Formats
Thread Structure
[PLACEHOLDER: Your typical thread format]
Example:
1. Hook (controversial or curiosity)
2. Context (1-2 tweets)
3. Main points (3-5 tweets)
4. Takeaway
5. CTAPost Templates
Hot Take Format
[PLACEHOLDER: Your hot take template]Story Format
[PLACEHOLDER: Your storytelling template]Educational Format
[PLACEHOLDER: Your teaching template]---
Examples
Voice in Action
<!-- Include 2-3 examples of your actual writing that captures your voice well -->
Example 1:
[PLACEHOLDER: Paste an example post/content that represents your voice]Example 2:
[PLACEHOLDER: Another example]---
Anti-Patterns
Doesn't Sound Like Me
<!-- Examples of writing styles to avoid -->
[PLACEHOLDER: e.g., "Overly formal corporate speak"]
[PLACEHOLDER: e.g., "Excessive hedging ('I think maybe perhaps...')"]
[PLACEHOLDER: e.g., "Clickbait without substance"]---
Last updated: [DATE]
{"_schema": "bookmark", "_version": "1.0", "_description": "Saved resources and links. Append only. Use categories: ai_agents, building, growth, productivity, leadership, industry, personal"}
{"id": "bm_example_001", "saved_at": "2024-01-01T00:00:00Z", "url": "[PLACEHOLDER: URL]", "title": "[PLACEHOLDER: Title]", "source": "article", "category": "ai_agents", "summary": "[PLACEHOLDER: 1-2 sentence summary]", "key_insights": ["[PLACEHOLDER: Key insight 1]", "[PLACEHOLDER: Key insight 2]"], "status": "unread", "rating": null, "tags": ["[tag1]", "[tag2]"]}
Competitive Landscape
Understanding your market and differentiating your positioning.
---
Direct Competitors
<!-- People/companies doing similar things to you -->
Competitor 1: [PLACEHOLDER: Name]
website: "[PLACEHOLDER]"
twitter: "[PLACEHOLDER]"
audience_size: "[PLACEHOLDER: Approximate]"
positioning: "[PLACEHOLDER: How they describe themselves]"What they do well:
- [PLACEHOLDER]
- [PLACEHOLDER]
Gaps/Weaknesses:
- [PLACEHOLDER]
- [PLACEHOLDER]
How we differentiate:
- [PLACEHOLDER]
---
Competitor 2: [PLACEHOLDER: Name]
website: "[PLACEHOLDER]"
twitter: "[PLACEHOLDER]"
audience_size: "[PLACEHOLDER]"
positioning: "[PLACEHOLDER]"What they do well:
- [PLACEHOLDER]
Gaps/Weaknesses:
- [PLACEHOLDER]
How we differentiate:
- [PLACEHOLDER]
---
Indirect Competitors
<!-- Adjacent players who could compete for attention -->
| Name | What They Do | Overlap | Differentiation |
|---|---|---|---|
| [PLACEHOLDER] | [PLACEHOLDER] | [PLACEHOLDER] | [PLACEHOLDER] |
| [PLACEHOLDER] | [PLACEHOLDER] | [PLACEHOLDER] | [PLACEHOLDER] |
---
Inspirations (Not Competitors)
<!-- People you admire and learn from -->
| Name | Why I Follow | What I Learn |
|---|---|---|
| [PLACEHOLDER] | [PLACEHOLDER] | [PLACEHOLDER] |
| [PLACEHOLDER] | [PLACEHOLDER] | [PLACEHOLDER] |
---
Market Trends
Growing
- [PLACEHOLDER: Trend and why it matters]
- [PLACEHOLDER]
Declining
- [PLACEHOLDER: Trend and implications]
- [PLACEHOLDER]
Emerging
- [PLACEHOLDER: New trends to watch]
- [PLACEHOLDER]
---
Positioning Matrix
High Technical Depth
|
[Competitor A] | [You?]
|
Low Accessibility -------- + -------- High Accessibility
|
[Competitor B] | [Competitor C]
|
Low Technical Depth---
Competitive Advantages
What I Have That Others Don't
1. [PLACEHOLDER: Unique experience] 2. [PLACEHOLDER: Unique perspective] 3. [PLACEHOLDER: Unique access/network]
Gaps in the Market I Can Fill
1. [PLACEHOLDER] 2. [PLACEHOLDER]
---
Last updated: [DATE]
Knowledge Base
Your second brain for research, learning, and information organization.
Files in This Module
| File | Format | Purpose |
|---|---|---|
bookmarks.jsonl | JSONL | Saved links and resources |
learning.yaml | YAML | Skills and learning goals |
competitors.md | Markdown | Competitive landscape |
research/ | Folder | Deep-dive research notes |
notes/ | Folder | Quick capture notes |
Data Schemas
Bookmark Entry
{
"id": "bm_YYYYMMDD_HHMMSS",
"saved_at": "ISO8601",
"url": "https://...",
"title": "Page title",
"source": "article|video|podcast|tool|tweet|paper",
"category": "category_name",
"summary": "1-2 sentence summary",
"key_insights": ["insight1", "insight2"],
"status": "unread|read|reviewed|archived",
"rating": 1-5,
"tags": ["tag1", "tag2"]
}Workflows
Saving a Resource
1. Append to bookmarks.jsonl with status "unread" 2. Add category and initial tags 3. Later: read, summarize, update status
Research Projects
1. Create research/[topic].md for deep dives 2. Link relevant bookmarks 3. Synthesize insights 4. Extract content ideas
Learning Tracking
1. Define skills in learning.yaml 2. Link resources to skills 3. Track progress and milestones 4. Review quarterly
Agent Instructions
<instructions> When managing knowledge:
1. Saving links: Always capture URL, title, and initial category 2. Organizing: Use consistent categories and tags 3. Retrieving: Search bookmarks.jsonl by category, tags, or keywords 4. Synthesizing: When asked about a topic, check research/ folder first 5. Learning updates: Update learning.yaml when completing resources
Categories to use:
- ai_agents: AI, agents, automation
- building: Startups, product, engineering
- growth: Marketing, audience, content
- productivity: Systems, tools, workflows
- leadership: Management, teams, culture
- industry: Market trends, competitors
- personal: Health, relationships, life
</instructions>
Knowledge Graph Hints
When retrieving information, consider connections:
- Bookmarks → Content ideas
- Research → Authority pieces
- Learning → Skills to highlight in brand
- Competitors → Differentiation angles
# Learning & Skills Development
# Track skills you're building and resources for each
current_focus:
skill: "[PLACEHOLDER: e.g., AI Agent Development]"
why: "[PLACEHOLDER: Why this is important now]"
target_level: "[PLACEHOLDER: e.g., Build production agents]"
deadline: "[PLACEHOLDER: Target date]"
skills:
# Technical Skills
- name: "[PLACEHOLDER: e.g., Python]"
category: "technical"
current_level: "beginner|intermediate|advanced|expert"
target_level: "[PLACEHOLDER]"
status: "learning|practicing|maintaining"
resources:
- type: "course|book|tutorial|project"
title: "[PLACEHOLDER]"
url: "[PLACEHOLDER]"
status: "not_started|in_progress|completed"
notes: "[PLACEHOLDER]"
milestones:
- "[PLACEHOLDER: e.g., Build first CLI tool]"
- "[PLACEHOLDER: e.g., Contribute to open source]"
last_practiced: "[DATE]"
- name: "[PLACEHOLDER: e.g., Content Writing]"
category: "creative"
current_level: "[PLACEHOLDER]"
target_level: "[PLACEHOLDER]"
status: "[PLACEHOLDER]"
resources: []
milestones: []
last_practiced: "[DATE]"
# Add more skills...
learning_queue:
# Resources waiting to be consumed
- title: "[PLACEHOLDER]"
type: "course|book|video|article"
url: "[PLACEHOLDER]"
priority: "high|medium|low"
skill: "[PLACEHOLDER: Related skill]"
estimated_time: "[PLACEHOLDER: e.g., 10 hours]"
added: "[DATE]"
completed:
# Track what you've finished
- title: "[PLACEHOLDER]"
type: "[PLACEHOLDER]"
completed: "[DATE]"
rating: 1-5
key_takeaways:
- "[PLACEHOLDER]"
- "[PLACEHOLDER]"
applied_to: "[PLACEHOLDER: How you used this knowledge]"
learning_habits:
daily_time: "[PLACEHOLDER: e.g., 30 minutes]"
best_time: "[PLACEHOLDER: e.g., 6am before work]"
preferred_formats:
- "[PLACEHOLDER: e.g., Video tutorials]"
- "[PLACEHOLDER: e.g., Building projects]"
quarterly_review:
last_review: "[DATE]"
skills_improved:
- "[PLACEHOLDER]"
skills_to_focus:
- "[PLACEHOLDER]"
resources_to_complete:
- "[PLACEHOLDER]"
Research: [TOPIC]
Metadata
created: "[DATE]"
updated: "[DATE]"
status: "exploring|synthesizing|complete"
related_pillars: ["[pillar1]", "[pillar2]"]
content_potential: "high|medium|low"---
Research Question
<!-- What are you trying to understand? -->
[PLACEHOLDER: The core question driving this research]Key Findings
Finding 1: [Title]
[PLACEHOLDER: What you learned]
Source: [URL or reference]
Confidence: high|medium|lowFinding 2: [Title]
[PLACEHOLDER]
Source: [URL or reference]
Confidence: high|medium|low---
Synthesis
<!-- Your interpretation and conclusions -->
[PLACEHOLDER: What does this all mean? What's your take?]---
Content Ideas
<!-- How can this research become content? -->
- [ ] Thread idea: [PLACEHOLDER]
- [ ] Post idea: [PLACEHOLDER]
- [ ] Deep dive: [PLACEHOLDER]
---
Related Resources
<!-- Links to bookmarks.jsonl entries or external sources -->
- PLACEHOLDER: Resource title
- PLACEHOLDER: Resource title
---
Open Questions
<!-- What you still don't know -->
- [PLACEHOLDER]
- [PLACEHOLDER]
---
Action Items
- [ ] [PLACEHOLDER: Next step]
- [ ] [PLACEHOLDER]
---
Research notes are living documents. Update as you learn more.
# Relationship Circles
# Organize your network by relationship depth
circles:
inner:
description: "Close relationships - friends, advisors, confidants"
touchpoint_frequency: "weekly"
members:
- "[PLACEHOLDER: Name - brief context]"
- "[PLACEHOLDER]"
active:
description: "Current collaborators, frequent interaction"
touchpoint_frequency: "bi-weekly"
members:
- "[PLACEHOLDER: Name - brief context]"
- "[PLACEHOLDER]"
network:
description: "Known contacts, periodic touchpoints"
touchpoint_frequency: "monthly"
members:
- "[PLACEHOLDER]"
- "[PLACEHOLDER]"
dormant:
description: "Historical connections, may reactivate"
touchpoint_frequency: "quarterly check-in"
members:
- "[PLACEHOLDER]"
# Specialized groups (overlaps with circles)
groups:
founders:
description: "Fellow founders I can learn from / collaborate with"
members:
- "[PLACEHOLDER]"
investors:
description: "Investors, potential investors, advisors"
members:
- "[PLACEHOLDER]"
creators:
description: "Content creators, potential collaborations"
members:
- "[PLACEHOLDER]"
mentors:
description: "People who guide and advise me"
members:
- "[PLACEHOLDER]"
mentees:
description: "People I mentor or help"
members:
- "[PLACEHOLDER]"
# Relationship goals
goals:
this_quarter:
- "[PLACEHOLDER: e.g., Deepen 3 relationships from network to active]"
- "[PLACEHOLDER: e.g., Make 5 valuable introductions]"
- "[PLACEHOLDER: e.g., Reactivate 2 dormant relationships]"
annual:
- "[PLACEHOLDER: e.g., Build inner circle of 10 trusted advisors]"
- "[PLACEHOLDER]"
# Maintenance reminders
maintenance:
weekly:
- "Check last_contact dates"
- "Send at least 3 value-add messages"
monthly:
- "Review dormant contacts"
- "Update contact notes after interactions"
quarterly:
- "Audit circle placements"
- "Review relationship goals"
{"_schema": "contact", "_version": "1.0", "_description": "Personal contact database. Append new contacts, update existing by rewriting with same id."}
{"id": "contact_example_001", "created": "2024-01-01T00:00:00Z", "updated": "2024-01-01T00:00:00Z", "name": "[PLACEHOLDER: Full Name]", "handle": "[PLACEHOLDER: @handle]", "email": "[PLACEHOLDER]", "company": "[PLACEHOLDER]", "role": "[PLACEHOLDER]", "location": "[PLACEHOLDER: City, Country]", "circle": "network", "how_met": "[PLACEHOLDER: How you met]", "relationship": "peer", "topics": ["[topic1]", "[topic2]"], "can_help_with": ["[PLACEHOLDER: What they can help you with]"], "you_can_help_with": ["[PLACEHOLDER: How you can help them]"], "notes": "[PLACEHOLDER: Personal notes, context, personality]", "last_contact": "2024-01-01T00:00:00Z", "links": {"twitter": "[PLACEHOLDER]", "linkedin": "[PLACEHOLDER]", "website": "[PLACEHOLDER]"}}
{"_schema": "interaction", "_version": "1.0", "_description": "Log of all meaningful interactions. Append only."}
{"id": "int_example_001", "date": "2024-01-01T00:00:00Z", "contact_id": "contact_example_001", "type": "call", "context": "[PLACEHOLDER: What you discussed]", "key_points": ["[PLACEHOLDER: Key point 1]", "[PLACEHOLDER: Key point 2]"], "follow_ups": ["[PLACEHOLDER: Action item 1]", "[PLACEHOLDER: Action item 2]"], "sentiment": "positive"}
Introductions Tracker
Managing introductions - made and received.
---
Pending Introductions
To Make
<!-- Introductions you've committed to making -->
| Person A | Person B | Why | Status | Notes |
|---|---|---|---|---|
| [PLACEHOLDER] | [PLACEHOLDER] | [PLACEHOLDER: Why this intro] | `to_reach_out | reached_out |
To Request
<!-- Introductions you want to ask for -->
| Target Person | Through Whom | Why You Want to Meet | Status |
|---|---|---|---|
| [PLACEHOLDER] | [PLACEHOLDER] | [PLACEHOLDER] | `to_ask |
---
Completed Introductions
Made
<!-- Successful intros you facilitated -->
| Date | Person A | Person B | Outcome |
|---|---|---|---|
| [DATE] | [PLACEHOLDER] | [PLACEHOLDER] | [PLACEHOLDER: What happened] |
Received
<!-- Intros made for you -->
| Date | From | Connected To | Outcome |
|---|---|---|---|
| [DATE] | [PLACEHOLDER] | [PLACEHOLDER] | [PLACEHOLDER] |
---
Introduction Template
Email/DM Double Opt-In
Subject: Introduction: [Person A] <> [Person B]
Hey [Person B],
[Brief context on why I'm reaching out]
I'd love to introduce you to [Person A]. [1-2 sentences on who they are and what they do]
I thought you two should connect because [specific reason for the intro].
Would you be open to an intro? [Person A] is already opted in.
Let me know!
[Your name]Making the Introduction
Subject: Introduction: [Person A] <> [Person B]
[Person A], meet [Person B]. [1-2 sentences about Person B]
[Person B], meet [Person A]. [1-2 sentences about Person A]
I thought you two should connect because [specific reason].
I'll let you take it from here!
[Your name]---
Introduction Principles
- Always double opt-in: Get permission from both sides first
- Be specific: Explain WHY they should meet
- Make it easy: Provide context so they can start the conversation
- Follow up: Check in to see if the intro was valuable
- Track outcomes: Learn what makes good intros
---
Last updated: [DATE]
Network Module
Your personal CRM for meaningful relationships.
Files in This Module
| File | Format | Purpose |
|---|---|---|
contacts.jsonl | JSONL | People database |
interactions.jsonl | JSONL | Meeting/conversation log |
circles.yaml | YAML | Relationship tiers and groups |
intros.md | Markdown | Pending/made introductions |
Data Schemas
Contact Entry
{
"id": "contact_[unique]",
"created": "ISO8601",
"updated": "ISO8601",
"name": "Full Name",
"handle": "@twitter_handle",
"email": "email@domain.com",
"company": "Company Name",
"role": "Their Role",
"location": "City, Country",
"circle": "inner|active|network|dormant",
"how_met": "How you met",
"relationship": "friend|mentor|peer|collaborator|investor|customer",
"topics": ["topic1", "topic2"],
"can_help_with": ["what they can help you with"],
"you_can_help_with": ["how you can help them"],
"notes": "Personal notes",
"last_contact": "ISO8601",
"links": {
"twitter": "url",
"linkedin": "url",
"website": "url"
}
}Interaction Entry
{
"id": "int_YYYYMMDD_HHMMSS",
"date": "ISO8601",
"contact_id": "contact_[id]",
"type": "call|coffee|dm|email|event|collab",
"context": "What you discussed",
"key_points": ["point1", "point2"],
"follow_ups": ["action1", "action2"],
"sentiment": "positive|neutral|needs_attention"
}Workflows
Before a Meeting
1. Look up contact in contacts.jsonl 2. Review recent interactions in interactions.jsonl 3. Check circles.yaml for relationship context 4. Note any pending follow-ups or intros
After a Meeting
1. Log interaction in interactions.jsonl 2. Update last_contact in contacts.jsonl 3. Add any follow-ups to operations/todos.md 4. Update relationship notes if needed
Making Introductions
1. Check both contacts in contacts.jsonl 2. Ensure mutual value (check can_help_with fields) 3. Log in intros.md 4. Track follow-through
Agent Instructions
<instructions> When managing relationships:
1. Looking up contacts: Search by name, handle, company, or topics 2. Pre-meeting prep: Compile contact info + recent interactions + shared interests 3. Logging interactions: Always include date, type, context, and follow-ups 4. Intro matching: Cross-reference can_help_with fields 5. Relationship maintenance: Flag contacts with stale last_contact dates
Circle definitions:
- inner: Close relationships, regular contact
- active: Current collaborators, frequent interaction
- network: Known contacts, periodic touchpoints
- dormant: Historical connections, may reactivate
</instructions>
Relationship Principles
networking_philosophy:
- "Give before you ask"
- "Quality over quantity"
- "Follow up is everything"
- "Be genuinely helpful"
- "Make warm intros, not cold"# Goals & OKRs
# Review quarterly, update progress weekly
current_period:
quarter: "[PLACEHOLDER: e.g., Q1 2025]"
theme: "[PLACEHOLDER: What's the overarching focus]"
objectives:
# Objective 1
- objective: "[PLACEHOLDER: e.g., Build a strong personal brand]"
why: "[PLACEHOLDER: Why this matters]"
key_results:
- description: "[PLACEHOLDER: e.g., Reach 10k Twitter followers]"
target: 10000
current: 0
unit: "followers"
status: "on_track|at_risk|behind|completed"
- description: "[PLACEHOLDER: e.g., Publish 12 newsletter issues]"
target: 12
current: 0
unit: "issues"
status: "on_track"
- description: "[PLACEHOLDER: e.g., Get featured in 3 podcasts]"
target: 3
current: 0
unit: "appearances"
status: "on_track"
# Objective 2
- objective: "[PLACEHOLDER: e.g., Launch MVP]"
why: "[PLACEHOLDER]"
key_results:
- description: "[PLACEHOLDER]"
target: 0
current: 0
unit: "[PLACEHOLDER]"
status: "on_track"
- description: "[PLACEHOLDER]"
target: 0
current: 0
unit: "[PLACEHOLDER]"
status: "on_track"
# Objective 3
- objective: "[PLACEHOLDER: e.g., Expand network]"
why: "[PLACEHOLDER]"
key_results:
- description: "[PLACEHOLDER]"
target: 0
current: 0
unit: "[PLACEHOLDER]"
status: "on_track"
annual_goals:
- goal: "[PLACEHOLDER: Big picture goal for the year]"
progress: "[PLACEHOLDER: Current status]"
- goal: "[PLACEHOLDER]"
progress: "[PLACEHOLDER]"
personal_goals:
# Non-work goals
health:
- "[PLACEHOLDER: e.g., Exercise 4x/week]"
relationships:
- "[PLACEHOLDER: e.g., Weekly calls with family]"
growth:
- "[PLACEHOLDER: e.g., Read 24 books]"
north_star:
metric: "[PLACEHOLDER: The one metric that matters most right now]"
current: "[PLACEHOLDER]"
target: "[PLACEHOLDER]"
why: "[PLACEHOLDER: Why this is the focus]"
review_log:
- date: "[DATE]"
notes: "[PLACEHOLDER: What you reviewed, adjusted, learned]"
{"_schema": "meeting", "_version": "1.0", "_description": "Meeting log with notes and action items. Append after each meeting."}
{"id": "mtg_example_001", "date": "2024-01-01T10:00:00Z", "title": "[PLACEHOLDER: Meeting title]", "type": "1on1|team|external|interview|pitch|advisory", "attendees": ["[PLACEHOLDER: Name]"], "duration_mins": 30, "agenda": ["[PLACEHOLDER: Topic 1]", "[PLACEHOLDER: Topic 2]"], "notes": "[PLACEHOLDER: Key discussion points]", "decisions": ["[PLACEHOLDER: What was decided]"], "action_items": [{"task": "[PLACEHOLDER]", "owner": "[PLACEHOLDER]", "due": "[DATE]"}], "follow_up": "[PLACEHOLDER: Next steps]"}
{"_schema": "metrics_snapshot", "_version": "1.0", "_description": "Weekly metrics snapshot. Append a new entry each week."}
{"id": "metrics_example_001", "week_of": "2024-01-01", "recorded_at": "2024-01-07T00:00:00Z", "audience": {"twitter_followers": 0, "newsletter_subscribers": 0, "linkedin_connections": 0, "youtube_subscribers": 0}, "engagement": {"avg_impressions": 0, "avg_engagement_rate": 0, "newsletter_open_rate": 0}, "content": {"posts_published": 0, "threads_published": 0, "newsletters_sent": 0}, "business": {"revenue": 0, "mrr": 0, "customers": 0, "leads": 0}, "personal": {"deep_work_hours": 0, "exercise_sessions": 0, "books_read": 0}, "notes": "[PLACEHOLDER: What stood out this week]"}
Operations Module
Your personal productivity operating system.
Files in This Module
| File | Format | Purpose |
|---|---|---|
todos.md | Markdown | Active task list |
goals.yaml | YAML | OKRs and goal tracking |
meetings.jsonl | JSONL | Meeting log and notes |
metrics.jsonl | JSONL | Key metrics tracking |
reviews/ | Folder | Weekly/monthly reviews |
Workflows
Daily Flow
1. Morning: Review todos.md, prioritize
2. Throughout: Check off completed, add new
3. Evening: Log any meetings, update metricsWeekly Review (Run every Sunday)
1. Run agents/scripts/weekly_review.py 2. Review completed vs. planned 3. Check metrics in metrics.jsonl 4. Plan next week's priorities 5. Update goals.yaml progress
Goal Setting (Quarterly)
1. Review previous quarter goals 2. Update goals.yaml with new OKRs 3. Break down into monthly targets 4. Align content calendar with goals
Agent Instructions
<instructions> When managing operations:
1. Todos: Use priority levels (P0-P3), keep list current 2. Goals: Reference before major decisions or planning 3. Meetings: Log immediately after with key takeaways 4. Metrics: Update at least weekly 5. Reviews: Generate insights, not just summaries
Priority levels:
- P0: Do today, blocking other work
- P1: Do this week, important
- P2: Do this month, valuable
- P3: Backlog, nice to have
When asked to help plan or prioritize: 1. Check current goals.yaml for alignment 2. Review existing todos.md capacity 3. Consider time-sensitivity and dependencies 4. Suggest realistic timelines </instructions>
Productivity Principles
principles:
- "Ruthless prioritization over busy work"
- "Completion > perfection for P1-P3"
- "Batch similar tasks together"
- "Protect deep work time"
- "Weekly reviews are non-negotiable"Weekly Review: Week of [DATE]
Metrics Snapshot
<!-- Pull from metrics.jsonl or fill manually -->
| Metric | Last Week | This Week | Change |
|---|---|---|---|
| Twitter followers | |||
| Newsletter subs | |||
| Posts published | |||
| Deep work hours |
---
What Got Done
Completed
<!-- List completed tasks -->
- [PLACEHOLDER]
- [PLACEHOLDER]
Shipped
<!-- Anything you put out into the world -->
- [PLACEHOLDER]
Progress on Goals
<!-- Reference goals.yaml -->
- [PLACEHOLDER: Goal] - [Progress made]
---
What Didn't Get Done
Carried Over
<!-- Tasks moving to next week -->
- [PLACEHOLDER] - Why: [reason]
Dropped
<!-- Tasks you're removing -->
- [PLACEHOLDER] - Why: [reason]
---
Wins
<!-- Celebrate what went well --> 1. [PLACEHOLDER] 2. [PLACEHOLDER]
Lessons Learned
<!-- What did you learn? --> 1. [PLACEHOLDER] 2. [PLACEHOLDER]
Challenges
<!-- What was hard? --> 1. [PLACEHOLDER]
---
Content Performance
Top Performing
<!-- What content did well? -->
- [PLACEHOLDER: Post/content] - [Metric/result]
Underperformed
<!-- What didn't land? Why? -->
- [PLACEHOLDER]
---
Relationships
New Connections
- [PLACEHOLDER]
Follow-ups Needed
- [PLACEHOLDER]
---
Next Week
Top 3 Priorities
1. [PLACEHOLDER] 2. [PLACEHOLDER] 3. [PLACEHOLDER]
Calendar Highlights
- [Day]: [PLACEHOLDER: Key event]
Content Planned
- [PLACEHOLDER]
---
Energy & Wellbeing
| Aspect | Rating (1-10) | Notes |
|---|---|---|
| Energy | ||
| Focus | ||
| Stress | ||
| Sleep |
---
Notes
[PLACEHOLDER: Any additional thoughts, ideas, or context]
---
Reviewed on: [DATE]
Task List
Today's Focus
P0 - Must Do Today
<!-- Blocking, urgent, non-negotiable -->
- [ ] [PLACEHOLDER: Critical task]
P1 - Do This Week
<!-- Important, needs attention soon -->
- [ ] [PLACEHOLDER: Important task]
- [ ] [PLACEHOLDER]
---
Active Tasks
P2 - This Month
<!-- Valuable, schedule when possible -->
- [ ] [PLACEHOLDER: Monthly task]
- [ ] [PLACEHOLDER]
P3 - Backlog
<!-- Nice to have, get to when P0-P2 clear -->
- [ ] [PLACEHOLDER: Backlog item]
- [ ] [PLACEHOLDER]
---
By Area
Building (Product/Business)
- [ ] [PLACEHOLDER]
Content
- [ ] [PLACEHOLDER]
Network/Relationships
- [ ] [PLACEHOLDER]
Learning
- [ ] [PLACEHOLDER]
Personal
- [ ] [PLACEHOLDER]
---
Waiting On
<!-- Tasks blocked by others -->
| Task | Waiting On | Since | Follow Up |
|---|---|---|---|
| [PLACEHOLDER] | [Person/Thing] | [DATE] | [DATE] |
---
Completed This Week
<!-- Move here when done, clear weekly -->
- [x] [PLACEHOLDER: Completed task] _(completed: DATE)_
---
Notes
[PLACEHOLDER: Any context, blockers, or notes about current priorities]---
Priority Guide:
- P0: Do today, everything else waits
- P1: Must complete this week
- P2: Target this month
- P3: Backlog, no deadline
{
"name": "digital-brain-skill",
"version": "1.0.0",
"description": "A structured personal operating system for founders, creators, and builders. Claude Code Skill and standalone template for AI-assisted personal brand management.",
"keywords": [
"claude-code",
"agent-skill",
"personal-brand",
"productivity",
"second-brain",
"knowledge-management",
"content-creation",
"ai-agents",
"context-engineering"
],
"author": "Murat Can Koylan",
"license": "MIT",
"repository": {
"type": "git",
"url": "https://github.com/muratcankoylan/digital-brain-skill"
},
"homepage": "https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering",
"bugs": {
"url": "https://github.com/muratcankoylan/digital-brain-skill/issues"
},
"scripts": {
"weekly-review": "python3 agents/scripts/weekly_review.py",
"content-ideas": "python3 agents/scripts/content_ideas.py",
"stale-contacts": "python3 agents/scripts/stale_contacts.py",
"setup": "node scripts/setup.js"
},
"engines": {
"node": ">=16.0.0"
},
"skill": {
"name": "digital-brain",
"version": "1.0.0",
"description": "Personal knowledge management system for founders, creators, and builders.",
"entrypoint": "SKILL.md"
}
}
Digital Brain
A personal operating system for founders, creators, and builders. Part of the Agent Skills for Context Engineering collection.
Overview
Digital Brain is a structured knowledge management system designed for AI-assisted personal productivity. It provides a complete folder-based architecture for managing:
- Personal Brand - Voice, positioning, values
- Content Creation - Ideas, drafts, publishing pipeline
- Knowledge Base - Bookmarks, research, learning
- Network - Contacts, relationships, introductions
- Operations - Goals, tasks, meetings, metrics
The system follows context engineering principles: progressive disclosure, append-only data, and module separation to optimize for AI agent interactions.
Architecture
digital-brain/
├── SKILL.md # Main skill definition (Claude Code compatible)
├── SKILLS-MAPPING.md # How context engineering skills apply
│
├── identity/ # Personal brand & voice
│ ├── IDENTITY.md # Module instructions
│ ├── voice.md # Tone, style, patterns
│ ├── brand.md # Positioning, audience
│ ├── values.yaml # Core principles
│ ├── bio-variants.md # Platform bios
│ └── prompts/ # Generation templates
│
├── content/ # Content creation hub
│ ├── CONTENT.md # Module instructions
│ ├── ideas.jsonl # Content ideas (append-only)
│ ├── posts.jsonl # Published content log
│ ├── calendar.md # Content schedule
│ ├── engagement.jsonl # Saved inspiration
│ ├── drafts/ # Work in progress
│ └── templates/ # Thread, newsletter, post templates
│
├── knowledge/ # Personal knowledge base
│ ├── KNOWLEDGE.md # Module instructions
│ ├── bookmarks.jsonl # Saved resources
│ ├── learning.yaml # Skills & goals
│ ├── competitors.md # Market landscape
│ ├── research/ # Deep-dive notes
│ └── notes/ # Quick captures
│
├── network/ # Relationship management
│ ├── NETWORK.md # Module instructions
│ ├── contacts.jsonl # People database
│ ├── interactions.jsonl # Meeting log
│ ├── circles.yaml # Relationship tiers
│ └── intros.md # Introduction tracker
│
├── operations/ # Productivity system
│ ├── OPERATIONS.md # Module instructions
│ ├── todos.md # Task list (P0-P3)
│ ├── goals.yaml # OKRs
│ ├── meetings.jsonl # Meeting notes
│ ├── metrics.jsonl # Key metrics
│ └── reviews/ # Weekly reviews
│
├── agents/ # Automation
│ ├── AGENTS.md # Script documentation
│ └── scripts/
│ ├── weekly_review.py
│ ├── content_ideas.py
│ ├── stale_contacts.py
│ └── idea_to_draft.py
│
├── references/ # Detailed documentation
│ └── file-formats.md
│
└── examples/ # Usage workflows
├── content-workflow.md
└── meeting-prep.mdSkills Integration
This example demonstrates these context engineering skills:
| Skill | Application |
|---|---|
context-fundamentals | Progressive disclosure, attention budget |
memory-systems | JSONL append-only logs, structured recall |
tool-design | Self-contained automation scripts |
context-optimization | Module separation, just-in-time loading |
See SKILLS-MAPPING.md for detailed mapping of how each skill informs the design.
Installation
As a Claude Code Skill
# User-wide installation
git clone https://github.com/muratcankoylan/digital-brain-skill.git \
~/.claude/skills/digital-brain
# Or project-specific
git clone https://github.com/muratcankoylan/digital-brain-skill.git \
.claude/skills/digital-brainAs a Standalone Template
git clone https://github.com/muratcankoylan/digital-brain-skill.git ~/digital-brain
cd ~/digital-brainQuick Start
1. Define your voice - Fill out identity/voice.md with your tone and style 2. Set your positioning - Complete identity/brand.md with audience and pillars 3. Add contacts - Populate network/contacts.jsonl with key relationships 4. Set goals - Define OKRs in operations/goals.yaml 5. Start creating - Ask AI to "write a post" and watch it use your voice
File Format Conventions
| Format | Use Case | Why |
|---|---|---|
.jsonl | Append-only logs | Agent-friendly, preserves history |
.yaml | Structured config | Human-readable hierarchies |
.md | Narrative content | Editable, rich formatting |
.xml | Complex prompts | Clear structure for agents |
Usage Examples
Content Creation
User: "Help me write a X thread about AI agents"
Agent Process:
1. Reads identity/voice.md for tone patterns
2. Checks identity/brand.md - confirms "ai_agents" is a pillar
3. References content/posts.jsonl for successful formats
4. Drafts thread matching voice attributesMeeting Preparation
User: "Prepare me for my call with Sarah"
Agent Process:
1. Searches network/contacts.jsonl for Sarah
2. Gets history from network/interactions.jsonl
3. Checks operations/todos.md for pending items
4. Generates pre-meeting briefWeekly Review
User: "Run my weekly review"
Agent Process:
1. Executes agents/scripts/weekly_review.py
2. Compiles metrics from operations/metrics.jsonl
3. Runs agents/scripts/stale_contacts.py
4. Presents summary with action itemsAutomation Scripts
| Script | Purpose | Run Frequency |
|---|---|---|
weekly_review.py | Generate review from data | Weekly |
content_ideas.py | Suggest content from knowledge | On-demand |
stale_contacts.py | Find neglected relationships | Weekly |
idea_to_draft.py | Expand idea to draft scaffold | On-demand |
# Run directly
python agents/scripts/weekly_review.py
# Or with arguments
python agents/scripts/content_ideas.py --pillar ai_agents --count 5Design Principles
1. Progressive Disclosure - Load only what's needed for the current task 2. Append-Only Data - Never delete, preserve history for pattern analysis 3. Module Separation - Each domain is independent, no cross-contamination 4. Voice First - Always read voice.md before any content generation 5. Platform Agnostic - Works with Claude Code, Cursor, any AI assistant
Contributing
This is part of the Agent Skills for Context Engineering collection.
Contributions welcome:
- New content templates
- Additional automation scripts
- Module enhancements
- Documentation improvements
License
MIT - Use freely, attribution appreciated.
---
Author: Muratcan Koylan Version: 1.0.0 Last Updated: 2025-12-29
File Format Reference
Detailed specifications for each file format used in Digital Brain.
---
JSONL Files
Schema Convention
Every JSONL file starts with a schema definition line:
{"_schema": "schema_name", "_version": "1.0", "_description": "Purpose of this file"}This line is skipped during data processing but documents the expected structure.
Common Fields
All data entries should include:
{
"id": "type_YYYYMMDD_HHMMSS", // Unique identifier
"created": "ISO8601", // Creation timestamp
"updated": "ISO8601" // Last modification (optional)
}ideas.jsonl
{
"id": "idea_20241229_143022",
"created": "2024-12-29T14:30:22Z",
"idea": "Content of the idea",
"source": "observation|conversation|reading|shower_thought",
"pillar": "content_pillar_name",
"status": "raw|developing|ready|published|archived",
"priority": "high|medium|low",
"notes": "Additional context",
"tags": ["tag1", "tag2"]
}posts.jsonl
{
"id": "post_20241229_160000",
"published": "2024-12-29T16:00:00Z",
"platform": "twitter|linkedin|newsletter|blog|youtube",
"type": "post|thread|article|video|podcast",
"content": "Full content or summary",
"url": "https://...",
"pillar": "content_pillar_name",
"metrics": {
"impressions": 0,
"likes": 0,
"comments": 0,
"reposts": 0,
"saves": 0
},
"metrics_updated": "2024-12-29T20:00:00Z",
"notes": "What worked/didn't",
"tags": ["tag1", "tag2"]
}contacts.jsonl
{
"id": "contact_johndoe",
"created": "2024-01-15T00:00:00Z",
"updated": "2024-12-29T00:00:00Z",
"name": "John Doe",
"handle": "@johndoe",
"email": "john@example.com",
"company": "Acme Inc",
"role": "CEO",
"location": "San Francisco, USA",
"circle": "inner|active|network|dormant",
"how_met": "Met at conference",
"relationship": "friend|mentor|peer|collaborator|investor|customer",
"topics": ["ai", "startups"],
"can_help_with": ["intros to VCs"],
"you_can_help_with": ["technical advice"],
"notes": "Personal context",
"last_contact": "2024-12-15T00:00:00Z",
"links": {
"twitter": "https://twitter.com/johndoe",
"linkedin": "https://linkedin.com/in/johndoe",
"website": "https://johndoe.com"
}
}interactions.jsonl
{
"id": "int_20241229_100000",
"date": "2024-12-29T10:00:00Z",
"contact_id": "contact_johndoe",
"type": "call|coffee|dm|email|event|collab",
"context": "Discussed partnership opportunity",
"key_points": ["Point 1", "Point 2"],
"follow_ups": ["Send proposal", "Intro to Sarah"],
"sentiment": "positive|neutral|needs_attention"
}bookmarks.jsonl
{
"id": "bm_20241229_120000",
"saved_at": "2024-12-29T12:00:00Z",
"url": "https://example.com/article",
"title": "Article Title",
"source": "article|video|podcast|tool|tweet|paper",
"category": "ai_agents|building|growth|productivity|leadership|industry|personal",
"summary": "1-2 sentence summary",
"key_insights": ["Insight 1", "Insight 2"],
"status": "unread|read|reviewed|archived",
"rating": 1-5,
"tags": ["tag1", "tag2"]
}meetings.jsonl
{
"id": "mtg_20241229_140000",
"date": "2024-12-29T14:00:00Z",
"title": "Meeting Title",
"type": "1on1|team|external|interview|pitch|advisory",
"attendees": ["John Doe", "Jane Smith"],
"duration_mins": 30,
"agenda": ["Topic 1", "Topic 2"],
"notes": "Discussion summary",
"decisions": ["Decision made"],
"action_items": [
{"task": "Task description", "owner": "John", "due": "2024-12-31"}
],
"follow_up": "Next steps"
}metrics.jsonl
{
"id": "metrics_20241229",
"week_of": "2024-12-23",
"recorded_at": "2024-12-29T00:00:00Z",
"audience": {
"twitter_followers": 5000,
"newsletter_subscribers": 1200,
"linkedin_connections": 3000,
"youtube_subscribers": 500
},
"engagement": {
"avg_impressions": 10000,
"avg_engagement_rate": 0.05,
"newsletter_open_rate": 0.45
},
"content": {
"posts_published": 7,
"threads_published": 2,
"newsletters_sent": 1
},
"business": {
"revenue": 0,
"mrr": 0,
"customers": 0,
"leads": 5
},
"personal": {
"deep_work_hours": 25,
"exercise_sessions": 4,
"books_read": 0.5
},
"notes": "Strong week for content"
}---
YAML Files
values.yaml
core_values:
- name: "Value Name"
description: "What it means"
in_practice: "How it shows up"
beliefs:
- "Belief statement"
contrarian_views:
- view: "The view"
reasoning: "Why you hold it"
non_negotiables:
- "Line you won't cross"
principles:
content_creation:
- "Principle"
business:
- "Principle"goals.yaml
current_period:
quarter: "Q1 2025"
theme: "Growth focus"
objectives:
- objective: "Objective statement"
why: "Why it matters"
key_results:
- description: "KR description"
target: 100
current: 25
unit: "followers"
status: "on_track|at_risk|behind|completed"
north_star:
metric: "The one metric"
current: 1000
target: 10000
why: "Why this matters most"learning.yaml
current_focus:
skill: "Skill name"
why: "Why learning this"
target_level: "Target proficiency"
deadline: "2025-03-31"
skills:
- name: "Skill name"
category: "technical|creative|business|personal"
current_level: "beginner|intermediate|advanced|expert"
target_level: "Target"
status: "learning|practicing|maintaining"
resources:
- type: "course|book|tutorial|project"
title: "Resource name"
url: "https://..."
status: "not_started|in_progress|completed"
milestones:
- "Milestone description"
last_practiced: "2024-12-29"circles.yaml
circles:
inner:
description: "Close relationships"
touchpoint_frequency: "weekly"
members:
- "Name - context"
active:
description: "Current collaborators"
touchpoint_frequency: "bi-weekly"
members:
- "Name - context"
groups:
founders:
description: "Fellow founders"
members:
- "Name"
goals:
this_quarter:
- "Relationship goal"---
Markdown Files
Structure Convention
All markdown files follow this structure:
# Title
Brief description.
---
## Section 1
Content...
---
## Section 2
Content...
---
*Last updated: [DATE]*Placeholder Convention
Use [PLACEHOLDER: description] for user-fillable fields:
### Your Story[PLACEHOLDER: Write your founder journey here]
---
XML Files
Prompt Template Structure
<?xml version="1.0" encoding="UTF-8"?>
<prompt name="prompt-name" version="1.0">
<description>
What this prompt does
</description>
<instructions>
<context>
Background for the task
</context>
<guidelines>
Rules to follow
</guidelines>
<output_requirements>
Expected output format
</output_requirements>
</instructions>
<examples>
Input/output examples
</examples>
</prompt>---
ID Generation
Convention
{type}_{YYYYMMDD}_{HHMMSS} or {type}_{unique_slug}
Examples:
idea_20241229_143022contact_johndoepost_20241229_160000bm_20241229_120000
Uniqueness
IDs must be unique within their file. Timestamp-based IDs ensure uniqueness for time-series data.
#!/bin/bash
# Digital Brain Installation Script
# Installs Digital Brain as a Claude Code skill
set -e
SKILL_NAME="digital-brain"
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
BRAIN_DIR="$(dirname "$SCRIPT_DIR")"
# Colors
GREEN='\033[0;32m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
echo -e "${BLUE}Digital Brain Installer${NC}"
echo "========================"
echo ""
# Detect installation type
echo "Where would you like to install Digital Brain?"
echo ""
echo "1) User-wide (recommended) - ~/.claude/skills/"
echo "2) Current project only - ./.claude/skills/"
echo "3) Custom location"
echo ""
read -p "Enter choice [1-3]: " choice
case $choice in
1)
TARGET_DIR="$HOME/.claude/skills/$SKILL_NAME"
;;
2)
TARGET_DIR="./.claude/skills/$SKILL_NAME"
;;
3)
read -p "Enter custom path: " custom_path
TARGET_DIR="$custom_path/$SKILL_NAME"
;;
*)
echo "Invalid choice. Exiting."
exit 1
;;
esac
# Create target directory
mkdir -p "$(dirname "$TARGET_DIR")"
# Check if already exists
if [ -d "$TARGET_DIR" ]; then
read -p "Directory exists. Overwrite? [y/N]: " overwrite
if [ "$overwrite" != "y" ] && [ "$overwrite" != "Y" ]; then
echo "Installation cancelled."
exit 0
fi
rm -rf "$TARGET_DIR"
fi
# Copy files
echo ""
echo "Installing to: $TARGET_DIR"
cp -r "$BRAIN_DIR" "$TARGET_DIR"
# Remove install script from target (not needed there)
rm -f "$TARGET_DIR/scripts/install.sh"
echo ""
echo -e "${GREEN}Installation complete!${NC}"
echo ""
echo "Next steps:"
echo "1. Navigate to your Digital Brain: cd $TARGET_DIR"
echo "2. Start with identity/voice.md - define your voice"
echo "3. Fill out identity/brand.md - your positioning"
echo "4. Add contacts to network/contacts.jsonl"
echo "5. Capture ideas in content/ideas.jsonl"
echo ""
echo "Claude Code will automatically discover the skill."
echo "Try: 'Help me write a post in my voice'"
echo ""
Skills Mapping: Digital Brain
This document maps how Agent Skills for Context Engineering principles are applied in the Digital Brain implementation.
---
Context Engineering Principles Applied
1. Context Fundamentals
| Concept | Source Skill | Digital Brain Application |
|---|---|---|
| Attention Budget | context-fundamentals | Module separation ensures only relevant content loads. Voice file (~200 lines) loads for content tasks; contacts file loads for network tasks. Never load everything. |
| Progressive Disclosure | context-fundamentals | Three-level architecture: L1 (SKILL.md metadata), L2 (module instructions), L3 (data files). Each level loads only when needed. |
| High-Signal Tokens | context-fundamentals | JSONL schemas include only essential fields. Voice profiles focus on patterns, not exhaustive rules. |
Design Decision:
"Find the smallest possible set of high-signal tokens that maximize the likelihood of some desired outcome."
Applied by keeping voice.md focused on distinctive patterns (signature phrases, anti-patterns) rather than generic writing advice Claude already knows.
---
2. Memory Systems
| Concept | Source Skill | Digital Brain Application |
|---|---|---|
| Append-Only Logs | memory-systems | All .jsonl files are append-only. Status changes via "status": "archived", never deletion. Preserves full history. |
| Structured Recall | memory-systems | Consistent schemas across files enable pattern matching. contact_id links contacts.jsonl to interactions.jsonl. |
| Episodic Memory | memory-systems | interactions.jsonl captures discrete events. posts.jsonl logs content with performance metrics for retrospective analysis. |
| Semantic Memory | memory-systems | knowledge/bookmarks.jsonl with categories and tags enables topic-based retrieval. |
Design Decision:
"Agents maintain persistent memory files to track progress across complex sequences."
Applied in operations/metrics.jsonl where weekly snapshots accumulate, enabling trend analysis without recomputing from raw data.
---
3. Tool Design
| Concept | Source Skill | Digital Brain Application |
|---|---|---|
| Self-Contained Tools | tool-design | Scripts in agents/scripts/ are standalone Python files. Each does one thing: weekly_review.py generates reviews, stale_contacts.py finds neglected relationships. |
| Clear Input/Output | tool-design | Scripts read from known paths, output structured text to stdout. No side effects unless explicitly documented. |
| Token Efficiency | tool-design | Scripts process data and return summaries. Agent receives results, not raw data processing logic. |
Design Decision:
"Tools should be self-contained, unambiguous, and promote token efficiency."
Applied by having content_ideas.py analyze bookmarks and past posts internally, returning only actionable suggestions rather than raw analysis.
---
4. Context Optimization
| Concept | Source Skill | Digital Brain Application |
|---|---|---|
| Module Separation | context-optimization | Six distinct modules (identity/, content/, knowledge/, network/, operations/, agents/) prevent cross-contamination. Content creation never needs to load network data. |
| Just-In-Time Loading | context-optimization | Module instruction files (IDENTITY.md, CONTENT.md, etc.) load only when that module is relevant. |
| Reference Depth | context-optimization | Main SKILL.md links to module docs which link to data files. Maximum two hops to any information. |
Design Decision:
"Rather than pre-loading all data, maintain lightweight identifiers and dynamically load data at runtime."
Applied in network module: agent first scans contacts.jsonl for matching name, then loads specific interactions.jsonl entries only for that contact.
---
5. Context Degradation (Mitigation)
| Risk | Source Skill | Digital Brain Mitigation |
|---|---|---|
| Context Rot | context-degradation | Module separation caps any single load. Voice file stays under 300 lines. Data files stream via JSONL (read line by line). |
| Stale Context | context-degradation | last_contact timestamps in contacts. stale_contacts.py proactively surfaces relationships needing attention. |
| Conflicting Instructions | context-degradation | Single source of truth per domain. Voice only in voice.md. Goals only in goals.yaml. No duplication. |
Design Decision:
"As context length increases, models experience diminishing returns in accuracy and recall."
Applied by keeping SKILL.md under 200 lines, each module instruction file under 100 lines, and using external files for data rather than inline content.
---
Architecture Decisions
Why JSONL for Logs?
✓ Append-only by design
✓ Stream-friendly (no full file parse)
✓ Schema per line (first line documents structure)
✓ Agent-friendly (standard JSON parsing)
✓ Grep-compatible for quick searches
✗ Not human-editable (use YAML/MD for configs)
✗ No transactions (acceptable for personal data)Why Markdown for Narrative?
✓ Human-readable and editable
✓ Rich formatting (tables, lists, code)
✓ Git-friendly diffs
✓ Universal rendering
Use for: voice, brand, calendar, todos, templatesWhy YAML for Config?
✓ Hierarchical structure
✓ Human-readable
✓ Comments supported
✓ Clean syntax for nested data
Use for: goals, values, circles, learningWhy XML for Prompts?
✓ Clear structure for agents
✓ Named sections (instructions, context, output)
✓ Variable placeholders
✓ Validation-friendly
Use for: content-generation templates, complex prompts---
Workflow Mappings
Content Creation → Skills Applied
User: "Write a post about building in public"
Skills Chain:
1. context-fundamentals → Load only identity module
2. memory-systems → Retrieve voice patterns from voice.md
3. context-optimization → Don't load network/operations
4. tool-design → Use content templates as structured scaffolds
Files Loaded:
- SKILL.md (50 tokens) - Routing
- identity/IDENTITY.md (80 tokens) - Module instructions
- identity/voice.md (200 tokens) - Voice patterns
- identity/brand.md (scan for pillars) - Topic validation
Total: ~400 tokens vs loading entire brain (~5000 tokens)Relationship Management → Skills Applied
User: "Prepare me for my call with Alex"
Skills Chain:
1. context-fundamentals → Load only network module
2. memory-systems → Query contacts, then interactions
3. context-optimization → Just-in-time loading of specific contact
4. tool-design → Structured output (brief format)
Files Loaded:
- SKILL.md (50 tokens) - Routing
- network/NETWORK.md (60 tokens) - Module instructions
- network/contacts.jsonl (scan for Alex) - Contact data
- network/interactions.jsonl (filter by contact_id) - History
Total: ~300 tokens for relevant context only---
Trade-offs and Rationale
| Decision | Trade-off | Rationale |
|---|---|---|
| Separate modules | More files to navigate | Prevents context bloat; enables targeted loading |
| JSONL for data | Less human-friendly | Optimized for agent parsing and append operations |
| No database | No query language | Simplicity; works offline; no dependencies |
| Python scripts | Requires Python runtime | Universal; readable; easy to extend |
| Placeholders not examples | User must fill in | Avoids "AI slop"; forces personalization |
---
Verification Checklist
When extending Digital Brain, verify:
- [ ] New files follow format conventions (JSONL/YAML/MD/XML)
- [ ] Module instruction files stay under 100 lines
- [ ] JSONL files include schema line as first entry
- [ ] Cross-module references are minimal
- [ ] Scripts are self-contained with clear I/O
- [ ] No duplicate sources of truth
---
Related Skills
This implementation draws from these skills in the collection:
| Skill | Primary Application |
|---|---|
context-fundamentals | Overall architecture, progressive disclosure |
context-degradation | Mitigation strategies, file size limits |
context-optimization | Module separation, just-in-time loading |
memory-systems | JSONL design, append-only patterns |
tool-design | Agent scripts, I/O patterns |
multi-agent-patterns | Future: delegation to specialized sub-agents |
---
This mapping demonstrates how theoretical context engineering principles translate to practical system design.
Related skills
Setup Matt Pocock SkillsScaffold the per-repo configuration that Matt Pocock’s engineering agent skills rely on so they understand the issue tracker, triage labels, and domain documentation la495k196k
Lark AppsConnect Claude, Cursor or custom agents directly to Lark (Feishu) for messaging, document automation, approval workflows and enterprise data access.402k
CavemanSlash token usage by roughly 75% while keeping every technical detail intact when working with Claude Code, Cursor or similar agents.391k94.7k
Lark Skill MakerQuickly turn any Lark/Feishu OpenAPI call or multi-step workflow into a reusable agent skill with its own SKILL.md.386k16k
Running Claude Code Via Litellm CopilotRun Claude Code at a fraction of the cost by routing requests through LiteLLM to the GitHub Copilot Chat API.270k72
Codex PetGenerate a complete Codex Pet spritesheet and metadata from one reference image without needing an OpenAI key or Codex Pro.246k10AI & Agent Buildingagents