Strategic Compact

Strategic compact planning automation and integration to align organizational goals with operational execution

Category: productivity Source: affaan-m/everything-claude-code

Strategic Compact is an AI skill for creating concise, information-dense summaries and handoff documents that capture essential context for session continuity. It covers context compression, decision recording, state serialization, priority identification, and knowledge transfer patterns that enable efficient continuation of work across agent sessions.

What Is This?

Overview

Strategic Compact provides structured approaches to condensing work context into transferable summaries. It handles extracting key decisions and their rationale from lengthy work sessions, recording current state including completed tasks and pending items, identifying blockers and dependencies that affect next steps, compressing technical context into minimal yet sufficient descriptions, prioritizing information by relevance to likely continuation scenarios, and formatting summaries for quick consumption by the next session or team member.

Who Should Use This

This skill serves AI agents that need to hand off work context across sessions, developers documenting progress for team handoffs, project managers creating status summaries for stakeholders, and teams maintaining continuity across shift changes or rotations.

Why Use It?

Problems It Solves

Long work sessions generate extensive context that is lost when sessions end. Without structured summaries, resuming work requires re-reading previous conversation or code changes. Verbose handoff documents waste the reader time on irrelevant details. Critical decisions and their reasoning get buried in conversation history.

Core Highlights

Context compression reduces lengthy sessions into actionable summaries. Decision recording captures not just what was decided but why, enabling informed continuation. State serialization documents exact progress for seamless resumption. Priority ordering ensures the most important context appears first.

How to Use It?

Basic Usage

from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class Decision:
    what: str
    why: str
    alternatives: list = field(default_factory=list)

@dataclass
class WorkState:
    completed: list = field(default_factory=list)
    in_progress: list = field(default_factory=list)
    blocked: list = field(default_factory=list)
    next_steps: list = field(default_factory=list)

@dataclass
class StrategicCompact:
    title: str
    timestamp: str = field(
        default_factory=lambda: datetime.now().isoformat()
    )
    decisions: list = field(default_factory=list)
    state: WorkState = field(default_factory=WorkState)
    context: dict = field(default_factory=dict)

    def summary(self):
        lines = [f"## {self.title}"]
        lines.append(f"Updated: {self.timestamp}")
        if self.state.completed:
            lines.append("\nDone:")
            for item in self.state.completed:
                lines.append(f"  - {item}")
        if self.state.next_steps:
            lines.append("\nNext:")
            for item in self.state.next_steps:
                lines.append(f"  - {item}")
        return "\n".join(lines)

Real-World Examples

import json

class CompactBuilder:
    def __init__(self, title):
        self.compact = StrategicCompact(title=title)

    def add_decision(self, what, why, alternatives=None):
        self.compact.decisions.append(
            Decision(what, why, alternatives or [])
        )
        return self

    def mark_completed(self, task):
        self.compact.state.completed.append(task)
        return self

    def mark_blocked(self, task, reason):
        self.compact.state.blocked.append(
            {"task": task, "reason": reason}
        )
        return self

    def add_next_step(self, step):
        self.compact.state.next_steps.append(step)
        return self

    def set_context(self, key, value):
        self.compact.context[key] = value
        return self

    def serialize(self):
        return json.dumps({
            "title": self.compact.title,
            "timestamp": self.compact.timestamp,
            "decisions": [
                {"what": d.what, "why": d.why,
                 "alternatives": d.alternatives}
                for d in self.compact.decisions
            ],
            "state": {
                "completed": self.compact.state.completed,
                "blocked": self.compact.state.blocked,
                "next_steps": self.compact.state.next_steps
            },
            "context": self.compact.context
        }, indent=2)

builder = CompactBuilder("Auth Feature Sprint")
builder.mark_completed("JWT token generation")
builder.mark_completed("Login endpoint")
builder.add_decision(
    "Use refresh tokens",
    "Avoid frequent re-authentication",
    ["Session cookies", "Short-lived tokens only"]
)
builder.mark_blocked("OAuth2 integration", "Awaiting client credentials")
builder.add_next_step("Implement token refresh endpoint")
builder.set_context("branch", "feature/auth")
print(builder.serialize())

Advanced Tips

Order content by actionability so the next session can start working immediately from the first item. Include file paths and line numbers for code-related context to eliminate search time. Separate decisions from observations to make the reasoning structure explicit.

When to Use It?

Use Cases

Use Strategic Compact when ending a work session that will be continued later, when handing off tasks between team members or agent sessions, when creating progress summaries for status updates, or when documenting architectural decisions during implementation.

Related Topics

Architecture decision records, sprint retrospective notes, knowledge management systems, session state persistence, and technical documentation practices complement strategic compacts.

Important Notes

Requirements

Clear identification of what constitutes essential versus tangential context. Structured format for consistent compact creation. Storage mechanism for persisting compacts across sessions.

Usage Recommendations

Do: prioritize next steps and blockers at the top of every compact for immediate actionability. Record decision rationale alongside the decision itself for future context. Keep compacts under one page to ensure they are read completely.

Don't: include raw conversation logs without extracting the key points. Omit blockers or dependencies that the next session needs to address. Create compacts so detailed that they take longer to read than re-deriving the context.

Limitations

Compression inevitably loses some nuance that may prove relevant in unexpected scenarios. The quality of a compact depends on correctly identifying what information matters. Automated context extraction may miss implicit decisions made during unstructured work.