anilcancakir/claude-code-plugins — Summary

A seven-plugin Claude Code marketplace by anilcancakir focused on developer productivity, with the standout feature being the strategic-compact plugin — a hook-driven context management system that triggers at 5 lifecycle events (SessionStart, PreToolUse, PostToolUse, PreCompact, Stop) to track tool usage and suggest strategic compaction at phase transitions. The other plugins address Serena MCP integration, Dart/Flutter LSP, pre-commit automation, business idea research, structured TDD implementation planning, and CLAUDE.md generation. Total: 5 lifecycle hooks (across plugins), 3 skills, 3 agents, multiple commands and scripts per plugin. The strategic-compact plugin is the most architecturally interesting — it uses shell scripts triggered by hooks to count tool calls, detect phase transitions (exploration→implementation), and inject compaction guidance at the right moment rather than relying on Claude's auto-compaction.

differs_from_seeds: The strategic-compact plugin is the closest to a context-compaction-handling system in any personal skill repo — closer to what ccmemory aims to provide for memory, but applied to session compaction timing. Unlike all 11 seeds, it treats compaction as a first-class workflow decision rather than an afterthought. The pre-commit-flow plugin's hook pattern (SessionStart + UserPromptSubmit) resembles spec-kit's approach (2 hooks per command), but is lighter.

anilcancakir/claude-code-plugins — Overview

Origin

Created by @anilcancakir, published with MIT license. The marketplace is focused on practical productivity and workflow improvements for Claude Code users.

Philosophy

The README presents a functional plugin listing without a manifesto, but the strategic-compact plugin embeds a clear philosophy:

Manual compaction at strategic points > Auto-compaction at arbitrary points

"Auto-compact triggers at context limits, often mid-task. Strategic compaction preserves context through logical phases and compacts at natural transition points."

This reflects a broader design philosophy across the plugins: phase-aware automation — detecting where the user is in the development cycle and providing appropriate guidance rather than blanket automation.

Plugins

Seven distinct plugins each solving a specific problem:

1. strategic-compact — Intelligent context compaction timing
2. serena-integration — Semantic code navigation with Serena MCP (zero-config)
3. dart-lsp — Dart/Flutter language server integration
4. pre-commit-flow — Automated code review, docs, and commits before git push
5. idea-research — Business idea validation and market research
6. implementation-planner — Structured TDD implementation planning
7. project-optimizer — Project setup, CLAUDE.md generation, brand guidelines

Most Notable Innovation

The strategic-compact plugin's hooks.json registers 5 lifecycle events with shell scripts:

• SessionStart → session-init.sh (initialize session tracking)
• PreToolUse → track-and-suggest.sh (count tool calls, suggest compaction)
• PostToolUse/Bash → milestone-detector.sh (detect test-pass, commit, build milestones)
• PreCompact → compact-instructions.sh (inject guidance before compaction)
• Stop → stop-check.sh (final check)

This is among the most complete hook coverage in any personal-curation repo in this batch.

anilcancakir/claude-code-plugins — Architecture

Distribution

• GitHub: anilcancakir/claude-code-plugins
• Install: /plugin marketplace add anilcancakir/claude-code-plugins then /plugin install <plugin>
• License: MIT
• Primary language: Shell (hooks/scripts)

Directory Structure

claude-code-plugins/
├── .claude-plugin/
│   └── marketplace.json
├── strategic-compact/
│   ├── .claude-plugin/
│   ├── hooks/
│   │   ├── hooks.json         # 5 lifecycle events
│   │   └── strategic-compact  # (hook scripts dir)
│   ├── scripts/
│   │   ├── session-init.sh
│   │   ├── track-and-suggest.sh
│   │   ├── milestone-detector.sh
│   │   ├── compact-instructions.sh
│   │   └── stop-check.sh
│   └── skills/
│       └── strategic-compact/
│           └── SKILL.md
├── serena-integration/
│   ├── .claude-plugin/
│   ├── scripts/
│   └── skills/
│       ├── serena-navigator/
│       ├── serena-refactor/
│       └── serena-memory/
├── dart-lsp/
│   └── ...
├── pre-commit-flow/
│   ├── .claude-plugin/
│   ├── hooks/
│   │   └── hooks.json         # SessionStart + UserPromptSubmit
│   ├── agents/
│   │   ├── code-reviewer.md
│   │   ├── doc-updater.md
│   │   └── test-checker.md
│   ├── commands/
│   └── scripts/
│       ├── detect-project-config.sh
│       └── git-status-context.sh
├── idea-research/
├── implementation-planner/
└── project-optimizer/

Hook Runtime

Shell scripts only — no Node.js/TypeScript runtime required (unlike CEK's Bun hooks). All hooks use ${CLAUDE_PLUGIN_ROOT} variable expansion.

Required Runtime

• Claude Code
• Bash/shell environment
• Serena MCP server (optional, for serena-integration plugin)

  claude mcp add serena -- uvx --from git+https://github.com/oraios/serena serena start-mcp-server
  

Configuration (strategic-compact)

Via environment variables:

export STRATEGIC_COMPACT_T1=50    # First suggestion (tool calls threshold)
export STRATEGIC_COMPACT_T2=75    # Second suggestion
export STRATEGIC_COMPACT_T3=100   # Strong recommendation
export STRATEGIC_COMPACT_TIME=1800 # Time threshold (30 min)

anilcancakir/claude-code-plugins — Components

strategic-compact Plugin

Skills (1):

Hooks (5 events):

serena-integration Plugin

Skills (3):

dart-lsp Plugin

Features: go-to-definition, find references, hover info, code analysis for Dart/Flutter.

pre-commit-flow Plugin

Agents (3):

Hooks (2 events):

idea-research Plugin

Business research and idea validation skills.

implementation-planner Plugin

Structured implementation planning with TDD emphasis.

project-optimizer Plugin

Project setup, brand guidelines, CLAUDE.md generation.

Total Primitive Count

• Skills: 4+ (1 strategic-compact + 3 serena + others)
• Agents: 3 (pre-commit-flow)
• Hooks: 7 (5 strategic-compact + 2 pre-commit-flow)
• Scripts: 7 shell scripts (5 strategic + 2 pre-commit)
• Commands: unknown exact count

anilcancakir/claude-code-plugins — Uniqueness

differs_from_seeds

The strategic-compact plugin addresses a problem none of the 11 seeds solve explicitly: when to compact. While ccmemory manages what to remember and all seeds handle context compaction passively, strategic-compact actively monitors session state (tool counts, phase transitions, milestones) to suggest the optimal compaction moment. The closest seed is spec-kit (18 hooks, 2 per command) in hook coverage, but spec-kit's hooks enforce workflow steps, not session meta-management. The 5-event hook registration (SessionStart + PreToolUse/all + PostToolUse/Bash + PreCompact + Stop) is the most complete lifecycle coverage in any single plugin examined in this batch.

Most Distinctive Feature

The PreCompact hook with compact-instructions.sh — this is the only plugin in the entire batch that fires before compaction to inject guidance on what to preserve. This turns the typically uncontrolled compaction event into a manageable transition with explicit preservation rules.

Positioning

• Context lifecycle management (when to compact) is the primary value proposition
• Seven pragmatic plugins covering practical developer workflow needs
• Configurable via environment variables (unusual level of user control)
• Light dependencies: shell scripts only (no Node.js/Bun required)

Observable Failure Modes

1. Shell script timing: All hooks have 5-second timeouts. On slow machines or large repos, scripts may time out before completing analysis.
2. Counter reset: If SessionStart hook misses (plugin not loaded, crashed), the counter starts from 0 mid-session giving wrong tool-call counts.
3. Milestone detection brittleness: milestone-detector.sh likely uses grep on Bash output — easily broken by non-standard test output formats.
4. Serena prerequisite friction: The serena-integration plugin requires a multi-step manual setup before any skill works.
5. HANDOFF.md naming convention: Relies on users knowing to reference HANDOFF.md in the next session — no automated loading.