glebis/claude-skills — Summary

The most expansive personal skill collection in this batch: 48 plugins spanning meetings, research, presentations, developer tools, integrations, and personal productivity, maintained by Gleb Kalinin (Berlin technologist, AI educator, solopreneur). The flagship tdd skill is architecturally the most sophisticated item in the entire batch — a full multi-agent TDD orchestration system with the Test Writer, Implementer, and Refactorer running as separate Task subagents with architecturally enforced context isolation (the Test Writer never sees implementation code; the Implementer never sees the spec). It includes session state via .tdd-state.json, --dry-run mode, --auto mode, 7 framework support, 18 documented anti-patterns, 11 failure recovery scenarios, and a run_tests.sh universal test runner. The gpt-image-2 skill ships a Python MCP-style interface with SOPS+age encrypted API key management, JSONL history tracking, and cost-estimation modes.

differs_from_seeds: The TDD skill is a superset of superpowers' test-driven-development skill (Archetype 1) but implemented as a multi-agent orchestrator with separate context isolation between test-writing and implementation phases — closer to BMAD's multi-persona pattern but with information boundary enforcement that none of the 11 seeds implement. The breadth of 48 plugins (integrating ElevenLabs, GPT Image 2, Telegram, Google Workspace, Zoom, etc.) is closest to a personal "Swiss Army knife" — no seed compares in scope diversity.

glebis/claude-skills — Overview

Origin

Created by Gleb Kalinin (glebis), described as "a Berlin-based technologist, AI educator, solopreneur and artist. He teaches in-depth agentic skills and workflows, productivity and values-based project management using AI tools." He runs Claude code labs and community.

Philosophy

The README doesn't have a single manifesto but the breadth reveals the philosophy: highly personal skill library as a curated productivity OS. Unlike most repos that target professional software teams, this one integrates personal tools (Gmail, Calendar, Telegram, ElevenLabs TTS, Chrome browsing history) alongside technical ones (TDD, GPT Image 2, RAG evaluation).

TDD Design Philosophy

From the TDD SKILL.md:

"The core innovation: the Test Writer never sees implementation code, and the Implementer never sees the specification. This prevents the LLM from leaking implementation intent into test design."

Design credits cited:

• tdd-guard (hook-enforced TDD)
• Matt Pocock's TDD Skill (vertical slicing)
• TDFlow (test quality as ceiling for implementation quality)
• alexop.dev (context isolation between phases)

GPT Image 2 Design Philosophy

The gpt-image-2 skill treats image generation as a professional production workflow:

• Cost controls with confirmation prompts
• Draft mode (10x cheaper) for iteration
• 14 style presets + 8 platform presets
• SOPS+age encrypted key management
• JSONL history with metadata sidecars

Community Orientation

Gleb teaches AI skills and runs a community — this skill pack is both personal tooling and teaching material, explaining the unusual breadth and polish of documentation.

glebis/claude-skills — Architecture

Distribution

• GitHub: glebis/claude-skills
• Install: Via Claude Code marketplace (glebis-skills in marketplace.json)
• License: None specified
• Primary language: JavaScript + Python (scripts)

Directory Structure (selected)

claude-skills/
├── .claude-plugin/
│   ├── marketplace.json    # 48 plugin entries
│   └── README.md
├── BUNDLES.md              # Plugin bundle definitions
├── tdd/
│   ├── SKILL.md            # 744 lines — most complex skill in batch
│   ├── references/
│   │   ├── agent_prompts.md
│   │   ├── anti_patterns.md
│   │   ├── framework_configs.md
│   │   └── layer_guide.md
│   └── scripts/
│       ├── run_tests.sh
│       ├── extract_api.sh
│       └── discover_docs.sh
├── gpt-image-2/
│   ├── SKILL.md
│   └── scripts/
│       └── gpt_image_2.py
├── gws/                    # Google Workspace CLI skill
├── present/                # Narrated HTML presentations (ElevenLabs)
├── balanced/               # Anti-sycophancy skill
├── tg-responder/           # Telegram responder
├── gmail/                  # Gmail integration
├── zoom/                   # Zoom integration
├── granola/                # Meeting notes
├── fathom/                 # Meeting intelligence
├── linear/                 # Linear project management
├── telegram/               # Telegram integration
├── llm-cli/                # LLM CLI integration
├── deep-research/          # Deep research workflow
├── rag-eval/               # RAG evaluation
├── codex/                  # Codex integration
... (48 total plugins)

TDD Architecture (per SKILL.md)

ORCHESTRATOR (main Claude context)
├─ Phase 0: Setup (detect framework, extract API, create state)
├─ Phase 1: Decompose into vertical slices → user approves
├─ FOR EACH SLICE:
│   ├─ Phase 2 (RED):     Task(Test Writer)  ← spec + API only
│   ├─ Phase 3 (GREEN):   Task(Implementer)  ← failing test + error only
│   └─ Phase 4 (REFACTOR): Task(Refactorer)  ← all code + green results
└─ Summary

Required Runtime

• Claude Code (primary)
• Python 3 (for gpt-image-2, gws scripts)
• run_tests.sh — universal test runner supporting Jest, Vitest, pytest, Go test, cargo test, RSpec, PHPUnit
• API keys for: OpenAI (gpt-image-2), Google (gws), ElevenLabs (present), Telegram Bot, etc.

glebis/claude-skills — Components

Plugin Count: 48 total

From marketplace.json (verified count: 48 entries).

Developer Skills (selected)

Communication + Productivity Skills (selected)

Data + Research Skills (selected)

TDD Sub-components (scripts)

TDD Reference Documents

glebis/claude-skills — Uniqueness

differs_from_seeds

The TDD skill surpasses superpowers' test-driven-development skill (Archetype 1) in every dimension: multi-agent context isolation (Test Writer, Implementer, Refactorer as separate Tasks with information boundaries), session state persistence (.tdd-state.json), --resume mode, --dry-run pipeline validation, 7-framework support, retry loops (5 implementer + 3 regression), and 18 documented anti-patterns. The information isolation (Implementer cannot see the spec) is not present in any of the 11 seeds and is the most principled application of context engineering theory in the entire corpus. The overall breadth (48 plugins integrating ElevenLabs, GPT Image 2, Telegram, Google Workspace, Zoom, RAG eval) exceeds any seed in scope diversity — closest to claude-flow in component count but entirely markdown/script-based without a runtime.

Most Distinctive Feature

Information isolation in multi-agent TDD: The Test Writer never sees implementation code; the Implementer never sees the spec. This is not just multi-agent orchestration — it's an architectural information boundary enforced by selective context injection. No other framework in the 11 seeds or this batch implements this pattern.

Second: --dry-run mode that renders all subagent prompts with actual variables and reports character counts before any code is written. This treats the orchestration pipeline itself as testable software.

Positioning

• Most sophisticated TDD implementation in any personal skill pack
• Highest plugin breadth (48) in this batch — personal productivity OS
• Community/teaching focus (Gleb runs Claude code labs)
• JavaScript developer primary — marketplace.json language is JavaScript

Observable Failure Modes

1. No license: The repo has no license file — unclear if skills can be incorporated into other projects
2. API key sprawl: 48 plugins require API keys for OpenAI, Google, ElevenLabs, Telegram, etc. — high setup cost
3. SOPS+age dependency: Encrypted key management is powerful but adds complexity for casual users
4. 7-framework run_tests.sh: Universal test runner may have edge cases on non-standard project setups
5. TDD context injection brittleness: If extract_api.sh doesn't correctly identify public API signatures, the Implementer works with wrong context
6. Cost estimation UX: The --estimate flag is opt-in — users who forget will get cost surprises on large image generation runs