brahma-bhaga
About
The `brahma-bhaga` skill is for generative ideation, transforming ambiguity into coherent new structures and nurturing nascent ideas. Use it when you need a fresh design for a novel problem with no existing template, especially after clearing old patterns. It focuses on structured emergence and bringing new patterns into existence from a cleared conceptual space.
Quick Install
Claude Code
Recommendednpx skills add pjt222/agent-almanac -a claude-code/plugin add https://github.com/pjt222/agent-almanacgit clone https://github.com/pjt222/agent-almanac.git ~/.claude/skills/brahma-bhagaCopy and paste this command in Claude Code to install this skill
Documentation
Brahma Bhaga
Generate creation from void/ambiguity → structured emergence of new patterns, approaches, solutions where none existed.
Use When
- After
shiva-bhagadissolution cleared stale patterns + made space - Genuinely novel problem, no template/precedent
- User req needs invention, not retrieval/adapt
- Many approaches exist, none chosen — creative act IS the choice
- Blank slate: new file, project, arch, approach
- Incremental mod hit limits → fresh design needed
In
- Required: Creative goal or void to fill (from conv ctx)
- Optional: Constraints (user req, tech limits)
- Optional: Seeds — fragments, inspirations, partial ideas
- Optional: What was dissolved (
shiva-bhagaout) — understanding fail guides create
Do
Step 1: Survey Void
Before creating, understand space available.
Creative Space Assessment:
+---------------------+---------------------------+------------------------+
| Dimension | Questions | Determines |
+---------------------+---------------------------+------------------------+
| Constraints | What MUST the creation | The boundary within |
| | satisfy? What is non- | which creativity |
| | negotiable? | operates |
+---------------------+---------------------------+------------------------+
| Freedom | What is NOT specified? | The degrees of freedom |
| | Where does the user leave | available for creative |
| | room for creative choice? | choice |
+---------------------+---------------------------+------------------------+
| Seeds | What fragments, partial | The starting material |
| | ideas, or inspirations | that informs but does |
| | already exist? | not dictate |
+---------------------+---------------------------+------------------------+
| Anti-patterns | What was tried before and | The space to avoid — |
| | failed? What approaches | creation that repeats |
| | were dissolved? | dissolved patterns |
+---------------------+---------------------------+------------------------+
| Context | What exists around the | The environment the |
| | void? What must the | creation must fit |
| | creation integrate with? | into |
+---------------------+---------------------------+------------------------+
- Map each dim honestly — esp constraints, often implicit
- Degrees of freedom = where real creation happens
- ID seeds w/o committing — they inform, not dictate
→ Clear picture: bounded by constraints, informed by seeds, opened by freedom.
If err: Fully constrained (no freedom) → re-examine. Often "fixed" constraints are preferences. Ask user if needed.
Step 2: Generate — Divergent
Produce multiple possibilities, don't evaluate.
- ≥3 distinct approaches
- Genuinely diff — not variations
- Each: core idea (1 sentence), constraint satisfy, distinctness, trade-offs
- Include ≥1 unconventional/risky
- Don't evaluate — generation + eval separate
→ ≥3 distinct approaches, each w/ clear identity + trade-off profile.
If err: All similar → generation too narrow. Return Step 1, find unexplored freedom. Or invert constraint: "opposite of obvious?"
Step 3: Evaluate — Convergent
Assess approaches vs space.
- Each approach:
- Constraint satisfaction: Meets non-negotiables?
- Elegance: Simplest that works?
- Resilience: Survives future perturbation?
- Integration: Fits surrounding ctx?
- Novelty: Genuinely new or rearranges old?
- Eliminate hard-constraint violators
- Choose based on user implicit values (simplicity? thoroughness? creativity?)
- Two equally strong → present both w/ trade-offs to user
→ One chosen approach (or clearly framed user choice) w/ articulated reasoning.
If err: None satisfies all constraints → constraints may contradict. Surface to user, don't force compromise on fundamentals.
Step 4: Manifest — Form
Exec chosen, give concrete form.
- Skeleton first: minimal structure embodying core
- Build outward, add detail as needed
- Each step: "Serving core or diluting?"
- Resist over-elaborate — done when nothing more can be removed
- Name it: clear descriptive ID capturing essence
→ Concrete creation embodying approach — code, plan, structure, design where void was.
If err: Manifestation diverges from approach → pause, re-read Step 3 selection. Drift = selection not fully committed. Recommit or re-select.
Step 5: Nurture
New creations fragile. Protect early stages.
- Test vs constraints — works as intended?
- Weakest point — where most likely to break?
- Strengthen weakest w/o over-eng
- Hand off to
vishnu-bhagafor preservation if persistent - Document creative choices: chosen, rejected, why
→ Tested, documented, ready for sustained use.
If err: Fails first test → in creation or test? Fundamentally flawed → Step 2 w/ failure as new anti-pattern seed.
Check
- Space surveyed before generating
- ≥3 genuinely distinct approaches
- Selection on explicit criteria, not default instinct
- Manifested core-out, building outward
- Tested vs constraints
- Choices documented for future ref
Traps
- Create before clear: Create w/o prior dissolve → new contaminated by old. Run
shiva-bhagafirst if cluttered - Single-option gen: Generate one then eval = executing first idea, not creation. Real creation needs divergent options
- Novelty for own sake: Unconventional when simple standard better. Novelty = tool, not goal
- Perfectionist manifest: Polish endlessly vs shipping working. Complete imperfect > incomplete perfect
- Unprotected creation: Manifest + move on w/o test/doc → vulnerable
→
shiva-bhaga— destruction creates void Brahma fills; dissolve before createvishnu-bhaga— preservation sustains what Brahma creates; handoff from create to maintainintrinsic— creative engagement benefits from autonomous motivation; creation thrives in flowlearn— when creation needs unheld knowledge, learn before generateadapt-architecture— morphic eq for creating new arch patterns from existing systems
GitHub Repository
Related Skills
content-collections
MetaThis skill provides a production-tested setup for Content Collections, a TypeScript-first tool that transforms Markdown/MDX files into type-safe data collections with Zod validation. Use it when building blogs, documentation sites, or content-heavy Vite + React applications to ensure type safety and automatic content validation. It covers everything from Vite plugin configuration and MDX compilation to deployment optimization and schema validation.
polymarket
MetaThis skill enables developers to build applications with the Polymarket prediction markets platform, including API integration for trading and market data. It also provides real-time data streaming via WebSocket to monitor live trades and market activity. Use it for implementing trading strategies or creating tools that process live market updates.
creating-opencode-plugins
MetaThis skill helps developers create OpenCode plugins that hook into 25+ event types like commands, files, and LSP operations. It provides the plugin structure, event API specifications, and implementation patterns for JavaScript/TypeScript modules. Use it when you need to intercept, monitor, or extend the OpenCode AI assistant's lifecycle with custom event-driven logic.
sglang
MetaSGLang is a high-performance LLM serving framework that specializes in fast, structured generation for JSON, regex, and agentic workflows using its RadixAttention prefix caching. It delivers significantly faster inference, especially for tasks with repeated prefixes, making it ideal for complex, structured outputs and multi-turn conversations. Choose SGLang over alternatives like vLLM when you need constrained decoding or are building applications with extensive prefix sharing.
