ContextKit — Summary

ContextKit is a Claude Code slash-command system by FlineDev implementing a 4-phase spec-driven development workflow for iOS/macOS Swift development. It ships commands for business spec creation, technical architecture research, numbered implementation task generation, supervised development execution, and backlog management — all built around a Context/Features/ directory structure that persists specs across sessions.

Important: ContextKit is marked "no longer actively maintained" in its README as of March 2026, with features evolved into PlanKit (a lighter plugin-based successor). Analysis is of the frozen 0.2.0 state.

Problem it solves: AI assistants are reactive — they wait for step-by-step instructions instead of understanding the bigger picture. ContextKit gives the AI planning intelligence to understand intent upfront, break down features systematically, and execute with specialized quality agents (accessibility, localization, code debt, error handling) without constant steering.

Distinctive trait: iOS/macOS/Swift specialization — the technical architecture phase explicitly includes "Swift/SwiftUI patterns and architectural decisions, Accessibility, localization, and privacy considerations." The quality agents (check-accessibility.md, check-localization.md, check-modern-code.md) are Swift-ecosystem-specific, making this the most domain-specialized framework in this batch.

Differs from seeds: Most similar to kiro (spec lifecycle with requirements/design/tasks phases and approval gates) and openspec (command-per-phase workflow) but with a Swift/iOS domain focus rather than general-purpose development. Unlike kiro which uses an IDE fork, ContextKit uses standard Claude Code slash-commands. The numbered S001-S999 task system resembles taskmaster-ai's task numbering but operates on markdown files rather than a JSON database.

ContextKit — Overview

Origin

Published by FlineDev on GitHub. 169 stars, 1 contributor (Cihat Gündüz, iOS developer). MIT license. Last commit: 2026-03-10. Language: Shell (installer). Status: No longer actively maintained — superseded by PlanKit.

Philosophy

"The real problem: AI assistants are reactive, not proactive. You have to spoon-feed them every single step... You're managing the AI instead of collaborating with it."

"The solution: ContextKit gives AI the planning intelligence to understand your project, suggest the right technical approach, break down features systematically, and guide you through proven development phases."

"And you stay in control: ContextKit enables AI autonomy at the right moments while keeping you in strategic control. You review and approve the spec, tech decisions, and implementation plan at key checkpoints."

Domain Focus

Explicitly iOS/macOS Swift development:

• Technical architecture phase includes Swift/SwiftUI patterns, Accessibility, Localization, Privacy
• Quality agents: check-accessibility.md, check-localization.md, check-modern-code.md
• Release commands: /ctxk:impl:release-app (AppStore) and /ctxk:impl:release-package (Swift packages)
• settings.json configured to use Sonnet model (sufficient quality while reducing 5h-limit risk)

Custom Status Line

ContextKit configures a custom Claude Code statusline:

5h-Usage: 73% (1.4h left) | Chat: ▓▓▓▓▓▓░░░░ 64% (128k/200k)

Migration Note

Per README (March 2026): "ContextKit is no longer actively maintained. Its planning features have evolved into PlanKit — a lighter, plugin-based system that integrates directly with Claude Code's plugin marketplace."

ContextKit — Architecture

Distribution

• Type: Standalone repo with bash installer
• License: MIT
• Language: Shell (installer), Markdown (commands/agents)

Install Method

curl -fsSL https://raw.githubusercontent.com/FlineDev/ContextKit/main/install.sh | bash

Then in Claude Code:

/ctxk:proj:init

Directory Tree

ContextKit/
├── Templates/
│   ├── Agents/              # 9 subagent files
│   │   ├── build-project.md
│   │   ├── check-accessibility.md
│   │   ├── check-code-debt.md
│   │   ├── check-error-handling.md
│   │   ├── check-localization.md
│   │   ├── check-modern-code.md
│   │   ├── commit-changes.md
│   │   ├── run-specific-test.md
│   │   └── run-test-suite.md
│   ├── Commands/
│   │   ├── bckl/            # Backlog commands
│   │   ├── impl/            # Implementation commands
│   │   ├── plan/            # Planning commands
│   │   └── proj/            # Project commands
│   ├── Backlog/             # Backlog templates
│   ├── Contexts/            # Context file templates
│   ├── Features/            # Feature spec templates (Spec.md, Tech.md, Steps.md)
│   ├── Formatters/          # Output format templates
│   ├── Guidelines/          # Project guidelines templates
│   ├── Scripts/             # Shell scripts
│   └── settings.json        # Claude Code settings (Sonnet model, custom statusline)
├── install.sh
└── CLAUDE.md / AGENTS.md

Project-Level Files (after /ctxk:proj:init)

project/
├── Context.md               # Project context (required by all commands)
├── Context/
│   └── Features/
│       ├── 001-FeatureName/ # Full feature folder (Spec.md, Tech.md, Steps.md)
│       └── 002-SmallFix.md  # Quick task (single file)
└── Backlog/                 # Ideas, bugs (priority-sorted)

Required Runtime

• bash
• Claude Code

ContextKit — Components

Commands (slash-commands, ~20)

Project Management

Systematic Feature Planning (Full Workflow)

Quick Workflow

Implementation

Backlog Management

Subagents / Quality Agents (9)

Template Files

ContextKit — Uniqueness & Positioning

Differs From Seeds

Most similar to kiro (Archetype 5 — spec lifecycle with phased spec files) and openspec (Archetype 2 — command-per-phase workflow). Like kiro, ContextKit uses a Spec.md / Tech.md / Steps.md artifact structure; unlike kiro, it runs on standard Claude Code slash-commands rather than a proprietary IDE. Like openspec, it has one command per workflow phase; unlike openspec, the commands produce persistent artifact files rather than in-session plans.

The domain specialization (iOS/macOS Swift) is unique in the seed corpus and in this batch. No other framework addresses Xcode/AppStore-specific release workflows.

Status: Archived / Superseded

The README's deprecation notice is significant: "no longer actively maintained, evolved into PlanKit." For researchers, this means the framework represents a design iteration that the author themselves found insufficient — the evolution to PlanKit (plugin-based, lighter) is informative about what didn't work.

Key pain points implied by the migration:

• The bash installer + template system was harder to update than a plugin marketplace
• The command namespace /ctxk:* was more cumbersome than plugin-managed commands

Observable Failure Modes

• Template version mismatch: each command has a Template Version: N comment; if templates are outdated, behavior changes but the agent doesn't know which version it has
• Context.md presence check is the only safety gate — if the file is present but empty or wrong, commands proceed with bad context
• Swift-specific quality agents are useless for non-Swift projects (this is documented: the framework is explicitly iOS-focused)
• Backlog binary-search prioritization is novel but adds workflow friction

Relationship to faf-cli

The faf conductor command in faf-cli references "Conductor integration" — ContextKit has no known connection to faf-cli's Conductor feature. Separate systems.