Back to Skills

brahma-bhaga

pjt222
Updated 2 days ago
8 views
17
2
17
View on GitHub
Metaaidesign

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

Recommended
Primary
npx skills add pjt222/agent-almanac -a claude-code
Plugin CommandAlternative
/plugin add https://github.com/pjt222/agent-almanac
Git CloneAlternative
git clone https://github.com/pjt222/agent-almanac.git ~/.claude/skills/brahma-bhaga

Copy 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-bhaga dissolution 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-bhaga out) — 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                   |
+---------------------+---------------------------+------------------------+
  1. Map each dim honestly — esp constraints, often implicit
  2. Degrees of freedom = where real creation happens
  3. 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.

  1. ≥3 distinct approaches
  2. Genuinely diff — not variations
  3. Each: core idea (1 sentence), constraint satisfy, distinctness, trade-offs
  4. Include ≥1 unconventional/risky
  5. 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.

  1. 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?
  2. Eliminate hard-constraint violators
  3. Choose based on user implicit values (simplicity? thoroughness? creativity?)
  4. 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.

  1. Skeleton first: minimal structure embodying core
  2. Build outward, add detail as needed
  3. Each step: "Serving core or diluting?"
  4. Resist over-elaborate — done when nothing more can be removed
  5. 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.

  1. Test vs constraints — works as intended?
  2. Weakest point — where most likely to break?
  3. Strengthen weakest w/o over-eng
  4. Hand off to vishnu-bhaga for preservation if persistent
  5. 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-bhaga first 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 create
  • vishnu-bhaga — preservation sustains what Brahma creates; handoff from create to maintain
  • intrinsic — creative engagement benefits from autonomous motivation; creation thrives in flow
  • learn — when creation needs unheld knowledge, learn before generate
  • adapt-architecture — morphic eq for creating new arch patterns from existing systems

GitHub Repository

pjt222/agent-almanac
Path: i18n/caveman-ultra/skills/brahma-bhaga
0
agentsagentskillsai-assisted-developmentclaude-codeskillsteams

Related Skills

content-collections

Meta

This 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.

View skill

polymarket

Meta

This 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.

View skill

creating-opencode-plugins

Meta

This 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.

View skill

sglang

Meta

SGLang 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.

View skill