What it does. This skill should be used for personal operating-system workflows: content creation, voice consistency, relationship lookup, meeting preparation, weekly review, goal tracking, personal brand management, and network management. Part of muratcankoylan/Agent-Skills-for-Context-Engineering (muratcankoylan/Agent-Skills-for-Context-Engineering).

Upstream	muratcankoylan/Agent-Skills-for-Context-Engineering
Skill file	examples/digital-brain-skill/SKILL.md
License	MIT
Author	Muratcan Koylan
Fetched	2026-09-10

Install

• npx skills add muratcankoylan/Agent-Skills-for-Context-Engineering --skill digital-brain-skill, or copy the skill folder into ~/.claude/skills/digital-brain-skill/.
• Raw file: curl -sL https://raw.githubusercontent.com/muratcankoylan/Agent-Skills-for-Context-Engineering/HEAD/examples/digital-brain-skill/SKILL.md

SKILL.md (verbatim)

name: digital-brain
description: "This skill should be used for personal operating-system workflows: content creation, voice consistency, relationship lookup, meeting preparation, weekly review, goal tracking, personal brand management, and network management."
version: 1.0.0

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 scripts

Identity Module (Critical for Content)

Always read identity/voice.md before generating any content.

Contains:

• voice.md - Tone, style, vocabulary, patterns
• brand.md - Positioning, audience, content pillars
• values.yaml - Core beliefs and principles
• bio-variants.md - Platform-specific bios
• prompts/ - Reusable generation templates

Content Module

Pipeline: ideas.jsonl → drafts/ → posts.jsonl

• Capture ideas immediately to ideas.jsonl
• Develop in drafts/ using templates/
• Log published content to posts.jsonl with metrics
• Plan in calendar.md

Network Module

Personal CRM with relationship tiers:

• inner - Weekly touchpoints
• active - Bi-weekly touchpoints
• network - Monthly touchpoints
• dormant - 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 publishing

Pre-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 context

Weekly 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.md

Examples

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:

• Agent Skills for Context Engineering
• Anthropic Context Engineering Guide

---

Skill Metadata

Created: 2024-12-29 Last Updated: 2024-12-29 Author: Murat Can Koylan Version: 1.0.0

Other files in this skill

• .gitignore
• AGENT.md
• HOW-SKILLS-BUILT-THIS.md
• README.md
• SKILLS-MAPPING.md
• agents/AGENTS.md
• agents/scripts/content_ideas.py
• agents/scripts/idea_to_draft.py
• agents/scripts/stale_contacts.py
• agents/scripts/weekly_review.py
• content/CONTENT.md
• content/calendar.md
• content/engagement.jsonl
• content/ideas.jsonl
• content/posts.jsonl
• content/templates/linkedin-post.md
• content/templates/newsletter.md
• content/templates/thread.md
• examples/content-workflow.md
• examples/meeting-prep.md
• identity/IDENTITY.md
• identity/bio-variants.md
• identity/brand.md
• identity/prompts/content-generation.xml
• identity/prompts/reply-generator.xml
• identity/values.yaml
• identity/voice.md
• knowledge/KNOWLEDGE.md
• knowledge/bookmarks.jsonl
• knowledge/competitors.md
• knowledge/learning.yaml
• knowledge/research/_template.md
• network/NETWORK.md
• network/circles.yaml
• network/contacts.jsonl
• network/interactions.jsonl
• network/intros.md
• operations/OPERATIONS.md
• operations/goals.yaml
• operations/meetings.jsonl
• operations/metrics.jsonl
• operations/reviews/_weekly_template.md
• operations/todos.md
• package.json
• references/file-formats.md
• scripts/install.sh

AGENT.md (verbatim)

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.md first, then use templates in content/templates/
• Looking up contacts: Search network/contacts.jsonl, check interactions.jsonl for history
• Content ideas: Check content/ideas.jsonl, run agents/scripts/content_ideas.py
• Task management: Use operations/todos.md, align with operations/goals.yaml
• Weekly review: Run agents/scripts/weekly_review.py

File Conventions

• .jsonl files: One JSON object per line, append-only
• .md files: Human-readable, freely editable
• .yaml files: Configuration and structured data
• _template.md or _schema entries: 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

HOW-SKILLS-BUILT-THIS.md (verbatim)

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 dependencies

The 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 structure

Not 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 pushy

This 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 above

4 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.

README.md (verbatim)

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.md

Skills 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-brain

As a Standalone Template

git clone https://github.com/muratcankoylan/digital-brain-skill.git ~/digital-brain
cd ~/digital-brain

Quick 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 attributes

Meeting 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 brief

Weekly 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 items

Automation 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 5

Design 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

SKILLS-MAPPING.md (verbatim)

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, templates

Why YAML for Config?

✓ Hierarchical structure
✓ Human-readable
✓ Comments supported
✓ Clean syntax for nested data

Use for: goals, values, circles, learning

Why 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.

agents/AGENTS.md (verbatim)

---

name: agents-module description: Automation scripts and agent helpers for the Digital Brain. Use these scripts for recurring tasks, summaries, and maintenance.

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 5

Script 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 user

Content 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 calendar

Pre-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 context

Custom 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

content/CONTENT.md (verbatim)

---

name: content-module description: Content creation hub - ideas, drafts, calendar, and published posts. Use for content planning, writing, and tracking.

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"

content/calendar.md (verbatim)

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]

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/templates/linkedin-post.md (verbatim)

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

content/templates/newsletter.md (verbatim)

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)

content/templates/thread.md (verbatim)

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

identity/IDENTITY.md (verbatim)

---

name: identity-module description: Personal brand, voice, values, and positioning. Reference before creating any content or representing the user externally.

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.md first
• New platform profile: Check bio-variants.md
• Strategic decisions: Reference values.yaml
• Content topics: Consult brand.md for 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

Back to muratcankoylan/Agent-Skills-for-Context-Engineering or Agent skills.