ed3dai/ed3d-plugins

Asking Clarifying Questions helps narrow ambiguous requirements before brainstorming by resolving contradictions, defining scope, and checking assumptions. Use it after initial context is gathered to avoid designing the wrong solution.

Brainstorming turns rough ideas into structured designs through guided questions, alternatives, and stepwise validation. Use it before implementation or planning to clarify goals, constraints, and approach.

Coding Effectively guides writing and refactoring code with correctness, explicit error handling, property-driven design, and clear module organization. Use it when implementing features, reviewing code, or choosing patterns across languages and runtimes.

Creating A Plugin explains how to structure a Claude Code plugin and write its manifest. Use it when packaging commands, agents, skills, hooks, or MCP servers for reuse across projects.

Creating an Agent explains how to design specialized subagents for Claude Code plugins or the Task tool. It covers trigger descriptions, tool limits, prompt structure, and testing agents.

Defense In Depth validates data at every layer it passes through so invalid values are caught by entry, business, environment, and debug checks. Use it when bad input causes failures deep in execution or tests bypass earlier validation.

Executing An Implementation Plan runs implementation plans phase by phase with fresh subagents for each task and review. It loads each phase just in time to reduce context use during multi-step work.

Finishing A Development Branch guides the last step of completed work by verifying tests, offering merge/PR/keep/discard choices, and cleaning up the branch accordingly. Use it when implementation is done and you need to integrate or close out the branch.

Functional Core Imperative Shell separates pure business logic from side effects when writing, refactoring, or reviewing code. It classifies files before creation so runtime code is placed in a pure core or thin shell.

Maintaining A Marketplace helps create, release, and audit a Claude Code Plugin Marketplace. It covers marketplace.json schema, version syncing, changelog entries, and validation to prevent drift between plugin.json and marketplace.json.

PostgreSQL Development Patterns guides database access code, schema design, and transaction handling in PostgreSQL. It covers TX_ transaction naming, read-write separation, UUID and JSONB typing, and snake_case conventions to reduce corruption and type errors.

Programming in React guides modern React component work with TypeScript, hooks, composition, and common pitfalls. Use it when creating or modifying .jsx/.tsx files, planning React features, or debugging React-specific issues.

Project Context Maintenance updates CLAUDE.md or AGENTS.md files when code changes contracts, APIs, or domain structure. It compares changes, checks affected contexts, and coordinates documentation updates at phase or branch completion.

Prompt Security Hardening helps you write prompts, CLAUDE.md files, and generated code without leaking secrets or using unsafe shell patterns. Use it when handling environment variables, credentials, file permissions, or git operations.

Property-Based Testing helps write tests for serialization, validation, normalization, and pure functions by generating inputs and checking invariants. Use it to choose strong properties like roundtrip or idempotence and match them to a testing library.

Testing With Subagents helps you verify a skill before deployment by running baseline scenarios without it, then pressure-testing the written skill against rationalization and loopholes. Use it when creating or editing rules that agents might try to bypass.

Two-Stage Fan-Out Analysis orchestrates worker, critic, and summarizer subagents to analyze large corpora that exceed one agent's context. Use it for parallel segmentation, review, and final synthesis with file-based task tracking and recovery.

TypeScript House Style defines house rules for TypeScript code, including type vs interface choices, function declaration style, immutability, and Result-based Functional Core patterns. Use it when writing or reviewing TS implementations and type declarations.

Using Generic Agents helps you choose between Haiku, Sonnet, and Opus for a task. Use it when deciding which generic agent fits the level of instruction, judgment, or sustained focus required.

Writing Claude Directives helps you write instructions for Claude behavior, including skills, CLAUDE.md files, and agent or system prompts. Use it when you need clearer compliance, token-efficient guidance, or better skill discovery.

Writing Claudemd Files helps you create or update CLAUDE.md files for a project or subdirectory. It covers top-level command and convention docs, domain-level contracts and intent, and required freshness dates.

Writing Good Tests helps you write and review tests that verify behavior, wait on real conditions, and use mocks only where they fit. Use it for test philosophy, isolation, and avoiding flaky patterns.

Writing Rust covers house style for writing, reviewing, and modifying Rust code. It focuses on error handling, type-system patterns, serde conventions, testing practices, and module organization.

Writing Skills applies test-driven development to skill documentation and creation. Use it when creating, editing, or verifying skills so you can test pressure scenarios first and close loopholes before deployment.

Writing for a Technical Audience helps you write docs, guides, API references, and other developer content with clarity, conciseness, and consistent terminology. Use it when text feels robotic, verbose, or hard to trust.