Claude Projects Memory & Next-Task Skill

Do this: We're losing 10-15 minutes per project switch restoring context; this native Memory and skill pattern automates prioritization and eliminates that overhead entirely.

Comparison to Current State

new value DIFFERENT ANGLE

Current:

New: This reel introduces Claude's native 'Memory' (auto-synthesized project learnings every 24h) as a potential *replacement or supplement* for handoff documents, offering a vendor-native, automated approach to persistent context beyond our manually generated handoff docs. It also demonstrates a specific '/next-task' skill prompt structure for integrating project memory with a task manager to drive daily work prioritization dynamically, something the existing plan doesn't detail.

new value DIFFERENT ANGLE

Current:

New: This reel provides a concrete, immediately portable prompt structure for a '/next-task' skill that blends project memory and task manager data, directly applicable to ReelBot's `agent_loop.py` or OpenClaw. It shifts from just 'generating reports' to 'actively prioritizing and prompting the next action' within an autonomous system by using the MCP protocol pattern for task manager integration.

Similar to: CLI-First Context Optimization for Claude Code (0% overlap)
Overlap: context management, zero cold starts, persistent persona
Different enough to proceed.

Reduces context-switching overhead between AIAS, TFWW, GnomeGuys, and DDB projects, potentially saving 10-15 minutes per session on context restoration and task prioritization.

Eliminate cold starts across ReelBot and OpenClaw by integrating Claude's native Memory with Supabase task data using the '/next-task' skill pattern.

Business Applications

MEDIUM Claude Code workflow optimization (claude-upgrades)

Test Claude Projects web interface with Memory enabled for one project (e.g., AIAS dashboard development) to compare against our current handoff document approach. Measure if 24h auto-synthesis reduces manual handoff overhead.

MEDIUM Autonomous task execution (reelbot)

Port the '/next-task' skill prompt structure to ReelBot's agent_loop.py: 'Find project in Supabase → Pull open tasks → Check recent context → Identify priority → Execute'. This mirrors the video's MCP pattern but uses our existing Supabase backend.

LOW OpenClaw skill development (openclaw)

Create an OpenClaw skill that queries our project status from Supabase (equivalent to the MCP task manager connection) so OpenClaw can answer 'What should I focus on today?' using real data from AIAS/TFWW/GnomeGuys databases.

Implementation Levels

L1 -- Note it: Document the Second Brain Stack pattern including Memory, MCP integration, and /next-task prompt structure.
L2 -- Build it: Build '/next-task' skill in ReelBot that queries Supabase tasks and context to autonomously prioritize execution.
L3 -- Go deep: Test Claude Projects Memory as handoff replacement for AIAS work and port the skill pattern to OpenClaw for daily briefings.

Tasks

0 selected

Rate this plan:

React Angle

We should validate this framework with our existing setup — we've essentially built a custom version of this with handoff docs and ReelBot, but the standardized 'Second Brain Stack' terminology gives us a framework to teach clients.

Repurpose Ideas

Create a carousel showing 'How We Built a Second Brain for 4 Simultaneous Companies' — comparing the video's generic stack vs our specific implementation (Claude Code CLI + Supabase + ReelBot)
Twitter/X thread documenting thespecific '/next-task' prompt we use in ReelBot's autonomous loop
YouTube Short showing side-by-side: Claude Projects Memory vs our Handoff Document system — which works better for agency work?

Engagement Hook

We've been running something similar but with a twist — using Supabase as the 'task manager' layer instead of Linear/Todoist. The MCP protocol makes this stack more accessible though. Have you found the auto-synthesized memory accurate enough to replace manual notes?

What This Video Covers

Angus - 'Nontechnical Tech Bro' persona. Creates content about AI productivity workflows for founders/operators. Not a deep technical expert but focuses on practical implementation patterns. Growing audience in the AI automation space (592 likes, engaged comment section).

Hook: 'Your projects forget you' — opens with the pain of losing context when switching between client projects

Set up separate Claude Projects for every distinct project (client work, products, etc.)
Use simple custom instructions template: Identity ('You are [X]'), Building ('We're building [Y]'), Goal ('Success looks like [Z]')
DISTINCTION: Knowledge = uploaded files/docs (manual/static), Memory = auto-synthesized by Claude every 24 hours (automatic)
Connect task managers (Todoist, Linear, Asana) via MCP (Model Context Protocol) to give Claude access to real task data
Create matching projects in both Claude and the task manager for bidirectional context
Build a '/next-task' skill with prompt: Find project → Pull open tasks → Check memory → Identify highest priority → Start working
Stack architecture: Layer 1 (Claude Projects = Context), Layer 2 (Task Manager = Execution via MCP)
Applicable to marketing and operations, not just coding

“Your projects forget you”

“Just get something simple [for custom instructions], bro”

“Knowledge = what you upload. Memory = what Claude learns”

“Not rhetorical anymore. Claude answers from your actual data”

“Two layers. Zero cold starts”

Key Insights

We already have context monitoring at 75% and handoff documents (handoff skill) — but Claude's native Memory (auto-synthesized every 24h) could supplement or replace some handoff doc generation
Current structure: Knowledge = static files (~/.claude/rules/standards.md), Skills = JSON prompts. The video suggests we could add a third layer: Memory = auto-synthesized project learnings
The '/next-task' skill pattern matches our ReelBot autonomous execution loop — could port this exact prompt structure to ReelBot's agent_loop.py or OpenClaw's skill system
Simple custom instructions template (Identity/Building/Goal) validates our current consolidation of rules into standards.md — keep it simple, don't over-engineer
MCP protocol for task managers is growing — we should monitor if ReelBot should expose an MCP server instead of just webhooks
Zero cold starts concept aligns perfectly with our handoff document goal — ensuring Claude Code CLI sessions resume with full context

Analysis Notes

What it is: A productivity framework combining Claude Projects (web interface, not just Code CLI) with MCP-connected task managers to create persistent project memory and autonomous task prioritization.

How it helps us: Directly applies to our Claude Upgrades initiative. We already have handoff documents and context monitoring, but this provides a structured approach to project-specific memory and potential integration with our existing task execution (ReelBot, OpenClaw). The Knowledge vs Memory distinction clarifies how to use Claude's native features alongside our custom solutions.

Limitations: We don't use traditional task managers (Todoist/Linear/Asana) for our core ops — we use Express cron jobs, ReelBot execution engine, and OpenClaw skills. The MCP approach might be less relevant than our current webhook/autonomous agent loop. Also, we primarily use Claude Code CLI, not Claude Projects web interface.

Who should see this: Dylan and the AI automation team working on Claude Upgrades — specifically to evaluate if we should migrate some workflows from pure CLI to Claude Projects with Memory features.

Reality Check

✅ [SOLID] "Just get something simple for custom instructions, don't overthink it" — Validates our current direction in Claude Upgrades — we recently consolidated from multiple rule files to single standards.md (~1.4k tokens). Audience comment @dpr410 ('BY THE GODS! This may be the stack of all stacks') confirms this resonates with power users.

🤔 [PLAUSIBLE] "Connect any task manager via MCP — Claude reads your real tasks" — MCP is Anthropic's standard and expanding, but requires specific server implementations. Comment @gods_will_media asks 'Do I need a task manager tho? Cant I just build it with Claude' — suggesting some audience prefers Claude-native solutions over integrations. We already have ReelBot handling task execution without traditional task managers.
Instead: Continue with our Supabase-backed task tracking (ReelBot execution engine) rather than introducing Linear/Asana overhead, but consider exposing our system via MCP for future interoperability.

✅ [SOLID] "Claude builds Memory automatically every 24 hours — saves everything to project memory" — This is a real Claude Projects feature (shown in frame 4: 'Updates every 24h'). However, we should verify: does this replace our handoff documents or supplement them? Our current hook triggers at 75% context; auto-memory happens every 24h regardless. Could reduce manual handoff generation.
Instead: Test hybrid approach: Use Claude's auto-Memory for 24h synthesis, keep manual handoff skill for immediate context transfers when switching projects mid-session.

Cost Breakdown →

Step	Prompt	Completion	Cost
analysis	11,861	2,820	$0.0115
similarity	1,552	590	$0.0006
plan	8,132	5,119	$0.0149
Total			$0.0270