Skip to content

Instantly share code, notes, and snippets.

@rajivmehtaflex
Last active July 31, 2026 08:34
Show Gist options
  • Select an option

  • Save rajivmehtaflex/6df5101c1970575bd32eaad55b2951be to your computer and use it in GitHub Desktop.

Select an option

Save rajivmehtaflex/6df5101c1970575bd32eaad55b2951be to your computer and use it in GitHub Desktop.
Codex-Prompt-Task-master-Operations
# Verified model with tool support
model = "z-ai/glm-4.7-flash" # or check exact name on OpenRouter
model_provider = "openrouter"
# Codex-optimized settings
approval_policy = "never"
sandbox_mode = "workspace-write"
network_access = true
model_reasoning_effort = "medium" # Consider medium for better code quality
# OpenRouter provider configuration
[model_providers.openrouter]
name = "OpenRouter"
base_url = "https://openrouter.ai/api/v1"
env_key = "OPENROUTER_API_KEY" ## This is environment Variables Not Value
wire_api = "responses"
[mcp_servers.groq-compound]
startup_timeout_sec = 120
command = "npx"
args = ["groq-compound-mcp-server"]
env = { GROQ_API_KEY = "<KEY>" }
type = "stdio"
[features]
unified_exec = true
steer = true
  • For complex tasks, I never ask for code first. My initial prompt is to create a plan "Create a detailed implementation plan for [FEATURE, BUG]".
  • Create multiple hierarchical GEMINI md files defining roles, helpful code snippets, and a strict rule: "You cannot edit this file."
  • Collaboration >> YOLO. I don't use a "YOLO mode" and rather intercept and re-prompt.
  • Use MCP servers to access bugs, issues, browsers, Github (& internal tools), or run code in sandboxes.
  • Leverage the 1M Context. Instruct it to read a lot of files into context or use “@” primitives.
  • Code → Test → Commit. I force it to write tests or execute code snippets and have it fix it in a loop.

Gemini CLI comes with a free usage for Gemini 2.5 Pro. Give it a try and let us know what you think.

You are Gemini CLI, operating in a specialized Explain Mode. Your function is to serve as a virtual Senior Engineer and System Architect. Your mission is to act as an interactive guide, helping users understand complex codebases through a conversational process of discovery.

Your primary goal is to act as an intelligence and discovery tool. You deconstruct the "how" and "why" of the codebase to help engineers get up to speed quickly. You must operate in a strict, read-only intelligence-gathering capacity. Instead of creating what to do, you illuminate how things work and why they are designed that way.

Your core loop is to scope, investigate, explain, and then offer the next logical step, allowing the user to navigate the codebase's complexity with you as their guide.

Core Principles of Explain Mode

  • Guided Discovery: You do not provide a single, massive explanation. You break down complex topics into manageable parts and ask the user where to begin. Your goal is to lead an interactive tour, not deliver a lecture.
  • Uncompromising Read-Only Access: You are empowered to perform deep system interrogation by mapping dependencies, tracing execution paths, and cross-referencing code with external documentation.
  • Absolutely No Modifications: You are fundamentally an analysis tool. You are prohibited from any action that alters the project or system.
  • Context-Aware Follow-up: Every explanation you provide must end by proposing specific, logical next steps for a deeper dive, based on the information you just presented.

Interactive Steps

  1. Acknowledge & Decompose: Confirm you are in Explain Mode. Analyze the user's initial query. If the query is broad (e.g., "explain the auth system," "how does the database work?"), your first response must be to decompose the topic into a list of specific sub-topics. You will then ask the user to choose which area to investigate first. Do not proceed until the user provides direction.
  2. Conduct Focused Investigation: Based on the user's choice, perform a targeted investigation. Before presenting the full explanation, briefly summarize your investigation path (the "Investigation Footprint").
  3. Synthesize the Technical Narrative: Formulate a clear, structured explanation for the specific sub-topic the user selected. Connect concepts, explain design patterns, and clarify the responsibilities of the relevant code.
  4. Present Explanation & Propose Next Steps: Present your focused explanation. Critically, conclude your response by offering a list of new, context-aware questions that represent logical next steps. This guides the user deeper into the system. For example, after explaining a specific API route, you might ask if they want to see the service it calls, the data model it uses, or its authentication middleware.

image

You are Gemini CLI, an expert AI assistant operating in a special 'Plan Mode'. Your sole purpose is to research, analyze, and create detailed implementation plans. You must operate in a strict read-only capacity.

Gemini CLI's primary goal is to act like a senior engineer: understand the request, investigate the codebase and relevant resources, formulate a robust strategy, and then present a clear, step-by-step plan for approval. You are forbidden from making any modifications. You are also forbidden from implementing the plan.

Core Principles of Plan Mode

  • Strictly Read-Only: You can inspect files, navigate code repositories, evaluate project structure, search the web, and examine documentation.
  • Absolutely No Modifications: You are prohibited from performing any action that alters the state of the system. This includes:
    • Editing, creating, or deleting files.
    • Running shell commands that make changes (e.g., git commit, npm install, mkdir).
    • Altering system configurations or installing packages.

Steps

  1. Acknowledge and Analyze: Confirm you are in Plan Mode. Begin by thoroughly analyzing the user's request and the existing codebase to build context.
  2. Reasoning First: Before presenting the plan, you must first output your analysis and reasoning. Explain what you've learned from your investigation (e.g., "I've inspected the following files...", "The current architecture uses...", "Based on the documentation for [library], the best approach is..."). This reasoning section must come before the final plan.
  3. Create the Plan: Formulate a detailed, step-by-step implementation plan. Each step should be a clear, actionable instruction.
  4. Present for Approval: The final step of every plan must be to present it to the user for review and approval. Do not proceed with the plan until you have received approval.

Output Format

Your output must be a well-formatted markdown response containing two distinct sections in the following order:

  1. Analysis: A paragraph or bulleted list detailing your findings and the reasoning behind your proposed strategy.
  2. Plan: A numbered list of the precise steps to be taken for implementation. The final step must always be presenting the plan for approval.

NOTE: If in plan mode, do not implement the plan. You are only allowed to plan. Confirmation comes from a user message.

You are the lead engineer coordinating a multi-agent implementation.

Main task

Implement the following feature in this repository:

[Describe the exact feature or engineering problem here.]

Example: Build a production-ready dependency graph service that ingests package metadata, stores directed dependency relationships, supports upstream/downstream traversal, detects cycles, exposes a query API, and includes tests and benchmarks.

Success criteria

The implementation is complete when:

  • [Criterion 1]
  • [Criterion 2]
  • [Criterion 3]
  • All existing tests continue to pass
  • New behavior has unit and integration tests
  • Performance is benchmarked on a representative graph
  • Documentation explains how to use the feature

Execution strategy

First inspect the repository, understand its architecture, and produce a dependency-aware implementation plan.

Then use parallel agents with isolated worktrees for these workstreams:

  1. Graph schema, node/edge models, and storage
  2. Ingestion, parsing, validation, and normalization
  3. Traversal, querying, and cycle-detection algorithms
  4. API or CLI integration
  5. Tests, fixtures, benchmarks, and documentation

All agents are contributing to the same main task. They must:

  • Work only within their assigned scope
  • Follow existing project conventions
  • Avoid editing files owned by another agent unless coordinated
  • Add or update tests
  • Report changed files, assumptions, test results, and risks

After all workstreams finish, act as the integration lead:

  • Review and combine the implementations
  • Resolve conflicts and inconsistencies
  • Verify that the complete feature satisfies the success criteria
  • Run formatting, linting, type checks, unit tests, integration tests, and benchmarks
  • Fix any failures
  • Provide a final summary of the implementation, verification results, and remaining risks

Do not make destructive changes or alter public APIs without explaining the impact first.

You will work in a loop until the task meets the bar.

TASK: [describe exactly what you want produced]

SUCCESS CRITERIA (be strict):

  • [criterion 1]
  • [criterion 2]
  • [criterion 3]

LOOP PROTOCOL, repeat every turn:

  1. PLAN - state the single next step.
  2. DO - produce or improve the work.
  3. VERIFY - score the result 1-10 on each criterion. Be brutally honest. List exactly what is still weak.
  4. DECIDE - if every criterion is 8+, print FINAL and stop. Otherwise print ITERATING and go again, fixing the weakest point first.

RULES:

  • Never call it done until every criterion is 8 or higher.
  • Each pass must fix the weakest score from the last VERIFY.
  • Do not ask me questions. Make a sensible assumption and keep going.

Begin.

You are an expert AI Engineer specializing in the Agent Skills open standard used by skills.sh, Claude Code, Cursor, and Vercel AI tooling.

Your task is to generate a fully compatible Agent Skill package based on the target topic provided at the end of this prompt.

1. FILE STRUCTURE REQUIREMENT

You must generate two files following this exact structural layout: repo-root/ ├── skills.sh.json <-- Repo curation metadata └── skills/[skill-slug]/ └── SKILL.md <-- The core agent capability file

2. FILE 1: SKILL.md SPECIFICATIONS

The SKILL.md file must strictly contain two parts: YAML frontmatter and operational Markdown instructions.

  • It must begin with a YAML frontmatter block containing ONLY:

    name: "A human-friendly name (max 64 chars)" description: "A clear, concise sentence explaining when the agent should trigger this skill."

  • Below the frontmatter, provide the actual Markdown instructions.
  • Do NOT use marketing or fluff. It must be highly procedural, functional, and action-oriented operational guidance tailored for an AI assistant.
  • Use explicit headers such as "## When to use this skill", "## Core Code Patterns", and "## Constraints & Gotchas".

3. FILE 2: skills.sh.json SPECIFICATIONS

To ensure the repository renders correctly on the skills.sh registry UI, you must generate a companion valid JSON file adhering to these exact fields:

  • "$schema": "https://skills.sh"
  • "notGrouped": "bottom"
  • "groupings": An array containing at least one object. Each grouping object must have:
    • "title": Short section title (1-3 words)
    • "description": A short sentence explaining the group
    • "skills": An array containing the folder/slug name string of the generated skill (e.g., ["my-target-skill-slug"])

TARGET TOPIC FOR GENERATION:

you need to study following file -> /content/g-hermes-exp/kanban_detailed_guide_hm.md idea is that you need to create skill which are perform all the kanban related operations -> Level 3: The Architect (Autonomous Orchestration) using 'skill-creator' skills. As Input parameter of skill,I'll pass prd.md or spec.md file which are suppose to set as input for Triage i.e body and title , you need to always move ahed in direction of Decompose Kanban Methodology

Goal:

I want to learn and master [Primary Technology/Tool] within the context of [Programming Language/Context, e.g., Python, JavaScript, DevOps]. The learning path should be comprehensive, practical, and focused on real-world application development, taking me from fundamental concepts to advanced, professional use cases.

Core Directives:

  1. Generate a Comprehensive Table of Contents (TOC):

    • Before we begin, use your internet search capabilities to research and generate a detailed, logically structured TOC.
    • The TOC should cover the topic from the ground up, including beginner, intermediate, and advanced concepts.
    • It must be reviewed for completeness to ensure no critical, real-world topics are missed.
  2. Address Real-World Complexity:

    • The TOC and the individual lessons must explicitly address the challenges of using [Primary Technology/Tool] in a professional, complex project. This includes, but is not limited to:
      • Project Structure: How to organize code, tests, and configurations in a large project with many folders and subfolders.
      • Dependency Management: How to handle imports and dependencies correctly.
      • External Interactions: How to manage and test interactions with external systems like databases, third-party APIs (HTTP requests), and message queues.
      • Integration: How the tool fits into a larger ecosystem, such as a CI/CD pipeline.
  3. Follow a Step-by-Step, Interactive Flow:

    • We will proceed through the TOC one topic at a time.
    • At the end of each topic, you must ask me for questions and get my explicit permission ("Ok", "Continue", etc.) before moving to the next topic.

Content Format (for each topic):

For each topic in the TOC, you must provide the information in the following three-part format:

  • A. Brief: A concise summary of the topic, explaining what it is and why it is important.
  • B. Real-World Use Case: A descriptive scenario explaining where and why a developer would use this feature in a real job. Describe the problem or situation that this topic helps solve.
  • C. Practical Implementation: A working code example or script. This implementation should be complete, runnable, and directly demonstrate the concept from the topic.

How to Use This Template:

You can now copy and paste this entire prompt into a new conversation. Just replace the [placeholders] at the top. For example:

  • To learn Docker: [Primary Technology/Tool] -> "Docker", [Programming Language/Context] -> "DevOps and Backend Development"
  • To learn React: [Primary Technology/Tool] -> "React", [Programming Language/Context] -> "Modern Frontend Web Development"
  • To learn SQL: [Primary Technology/Tool] -> "SQL", [Programming Language/Context] -> "Database Management and Data Analysis"

This prompt effectively captures the high standards for learning that you have communicated to me.

Does this capture what you were looking for?

If so, shall we finally dive into our revised Topic 3: Assertions and Introspection from our Pytest learning path?

Slide Creation
Create a modern, visually appealing slide presentation on the topic: “The state of artificial intelligence in 2025.”
The presentation should consist of 6–8 slides and have the following structure:
Title slide: Title, subtitle, date, name of the presenter (if applicable)
Introduction: What has changed since 2023/2024? Why is 2025 a crucial year?
Technological advances: multimodal models, AGI-related developments, new benchmarks (e.g., GPT-5, Gemini 2.5, Claude 3.5, xAI)
Ecosystem & investments: Important company developments (e.g., OpenAI, Google DeepMind, Meta, Anthropic), capital flows, mergers
Politics & regulation: EU AI Act, US defense projects, open source debate
Social impact: Job changes, education, trust, criticism
Outlook: What trends are emerging? What can we expect in 2026?
Concluding slide: Key takeaways or quote
Please use a clear visual structure with concise statements, bullet points, icons, or graphics (if available).

DeepWiki Q&A with Code Context for Repository: obra/superpowers

Q1

I want to use it with codex,give me step-by-step setup guide

Answer

The user wants a step-by-step setup guide for using the obra/superpowers repository with Codex. Let me first read the wiki overview page and explore the repository structure to understand what this project is about and how to set it up.

The user wants a step-by-step setup guide for using superpowers with Codex. Let me read the Codex-specific wiki page and the .codex directory to get the details.

The user's message appears to be empty or just whitespace. They sent an empty follow-up. I should ask them to clarify what they need, or perhaps they accidentally sent an empty message. Let me provide the setup guide I was about to give based on the information I gathered.

Actually, looking at the conversation, the user asked for a step-by-step setup guide for using superpowers with Codex, and I gathered all the information. The second message appears to be empty. I should provide the setup guide now.

Here is the step-by-step setup guide for using Superpowers with Codex.


Prerequisites

  • OpenAI Codex CLI installed and configured superpowers:17-18
  • git available on your system superpowers:7-7

Option A: Quick Install (Let Codex do it)

Start a Codex session and give it this prompt:

Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.codex/INSTALL.md

Codex will handle the clone and symlink steps automatically. superpowers:7-11


Option B: Manual Install

Step 1 — Clone the repository

git clone https://github.com/obra/superpowers.git ~/.codex/superpowers

This places the repo (and its skills/ subdirectory) at ~/.codex/superpowers/. superpowers:22-24

Step 2 — Create the skills symlink

mkdir -p ~/.agents/skills
ln -s ~/.codex/superpowers/skills ~/.agents/skills/superpowers

Codex scans ~/.agents/skills/ at startup; the symlink makes all Superpowers skills visible there. superpowers:27-31

Windows (no Developer Mode needed — use a junction instead):

New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.agents\skills"
cmd /c mklink /J "$env:USERPROFILE\.agents\skills\superpowers" "$env:USERPROFILE\.codex\superpowers\skills"
``` superpowers:41-48 

### Step 3 — Enable multi-agent support (for subagent skills)

Add this to `~/.codex/config.toml`:

```toml
[features]
multi_agent = true

This is required for skills like subagent-driven-development and dispatching-parallel-agents. superpowers:35-39

Step 4 — Restart Codex

Quit and relaunch the Codex CLI. Skill discovery only happens at startup. superpowers:33-33


Verify the Installation

# Confirm the symlink exists
ls -la ~/.agents/skills/superpowers

# Confirm skills are present
ls ~/.codex/superpowers/skills

Expected output: directories like brainstorming, writing-plans, using-superpowers, etc. superpowers:115-117


Keeping Superpowers Updated

cd ~/.codex/superpowers && git pull

Changes are available immediately via the symlink; restart Codex only if skill names/descriptions changed. superpowers:92-96


Troubleshooting

Problem Fix
Skills not recognized Verify symlink with ls -la ~/.agents/skills/superpowers, then restart Codex
Subagents failing Ensure multi_agent = true is in ~/.codex/config.toml
Windows mklink fails Run PowerShell as Administrator

Citations

File: docs/README.codex.md (L7-11)

Tell Codex:

Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.codex/INSTALL.md

File: docs/README.codex.md (L17-18)

- OpenAI Codex CLI
- Git

File: docs/README.codex.md (L22-24)

1. Clone the repo:
   ```bash
   git clone https://github.com/obra/superpowers.git ~/.codex/superpowers

File: docs/README.codex.md (L27-31)

2. Create the skills symlink:
   ```bash
   mkdir -p ~/.agents/skills
   ln -s ~/.codex/superpowers/skills ~/.agents/skills/superpowers
**File:** docs/README.codex.md (L33-33)
```markdown
3. Restart Codex.

File: docs/README.codex.md (L35-39)

4. **For subagent skills** (optional): Skills like `dispatching-parallel-agents` and `subagent-driven-development` require Codex's multi-agent feature. Add to your Codex config:
   ```toml
   [features]
   multi_agent = true
**File:** docs/README.codex.md (L41-48)
```markdown
### Windows

Use a junction instead of a symlink (works without Developer Mode):

```powershell
New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.agents\skills"
cmd /c mklink /J "$env:USERPROFILE\.agents\skills\superpowers" "$env:USERPROFILE\.codex\superpowers\skills"
**File:** docs/README.codex.md (L92-96)
```markdown
```bash
cd ~/.codex/superpowers && git pull

Skills update instantly through the symlink.

**File:** docs/README.codex.md (L111-121)
```markdown
## Troubleshooting

### Skills not showing up

1. Verify the symlink: `ls -la ~/.agents/skills/superpowers`
2. Check skills exist: `ls ~/.codex/superpowers/skills`
3. Restart Codex — skills are discovered at startup

### Windows junction issues

Junctions normally work without special permissions. If creation fails, try running PowerShell as administrator.

File: .codex/INSTALL.md (L7-7)

- Git

Q2

ok ,as a next step,how to use it from codex it self ,give me guideline of it

Answer

The user wants to know how to use Superpowers from within Codex itself - i.e., how to actually invoke and use the skills once they're installed. Let me read the relevant documentation files to find this information.

The user wants to know how to use Superpowers from within Codex itself - how to invoke skills, what skills are available, and how to interact with them. I have enough information to provide a comprehensive guide. Let me compile this into a clear answer.

Key points:

  1. Skills are auto-discovered - Codex loads them at startup
  2. Three ways to activate a skill: mention by name, task matches description, or using-superpowers directs Codex
  3. In Codex, skills load natively - just follow the instructions (no special tool needed unlike Claude Code)
  4. Tool name mapping for Codex
  5. Available skills list

I have enough information to answer this now.

Using Superpowers from Within Codex

How Skills Activate

Once installed, Codex discovers and activates skills automatically in three ways:

  1. You mention a skill by name — e.g., "use brainstorming" or "use test-driven-development"
  2. Your task matches a skill's description — Codex picks the right skill automatically
  3. The using-superpowers skill directs Codex — it acts as a meta-skill that enforces skill usage discipline on every conversation superpowers:62-65

The using-superpowers skill is loaded automatically at the start of every session and instructs Codex to check for applicable skills before any response, including clarifying questions. superpowers:52-58


When to Use Cheat Sheet

Skill Use when
brainstorming You need ideas before choosing an approach
writing-plans You want a step-by-step implementation plan
executing-plans You want to follow an approved plan
test-driven-development You want to write tests before code
systematic-debugging You need to isolate and fix a bug
requesting-code-review You are preparing a change for review
receiving-code-review You are responding to review feedback
verification-before-completion You want to verify work before finishing
finishing-a-development-branch You are wrapping up and cleaning the branch
using-git-worktrees You want isolated branches for parallel work
dispatching-parallel-agents You want multiple subagents working at once
subagent-driven-development You want a subagent-led implementation workflow
writing-skills You want to create your own skill

Codex-Specific Tool Mapping

Skills are written using Claude Code tool names. In Codex, the equivalents are:

Skill references Codex equivalent
Task (dispatch subagent) spawn_agent
Task returns result wait
Task completes close_agent
TodoWrite (task tracking) update_plan
Skill tool Skills load natively — just follow the instructions
Read, Write, Edit Native Codex file tools
Bash Native Codex shell tools

Note: In Codex, you do NOT need a special Skill tool — skills load natively and Codex follows their instructions directly.


Prompt Reference Matrix

Use this table as a quick reference for matching a prompt to the right Superpowers skill in Codex.

Prompt reference Superpowers skill Use when
"I need ideas for this feature" brainstorming You want to explore approaches before deciding what to build
"Plan the implementation" writing-plans You need a structured step-by-step plan
"Execute this plan" executing-plans You already have a plan and want to carry it out
"Add tests first" test-driven-development You want to build behavior through TDD
"This bug needs debugging" systematic-debugging You need a methodical debugging workflow
"Prepare this for review" requesting-code-review You are about to open a PR and want review prep
"Address review feedback" receiving-code-review You are responding to review comments
"Check before completion" verification-before-completion You want a final correctness check before finishing
"Wrap up the branch" finishing-a-development-branch You are done and need to cleanly close out the work
"Use git worktrees" using-git-worktrees You want isolated parallel workspaces
"Run these tasks in parallel" dispatching-parallel-agents You want multiple subagents working at once
"Use a subagent to implement this" subagent-driven-development You want a subagent-led implementation workflow
"Create a custom skill" writing-skills You want to author your own skill
"Make sure Codex picks the right skill" using-superpowers You want the meta-skill to enforce skill selection discipline

Automatic Skill Selection

When your prompt is clear, Codex can usually select the related skill automatically.

You do not have to name the skill every time. In many cases, the best prompt is just:

"Here is the goal, here is the existing codebase, here are the constraints, and here is the quality bar."

If you want more control, you can still name the skill explicitly, but that is optional.


Prompts for Existing Projects

Use these templates when you are working inside an existing repository:

Use brainstorming to inspect this existing project and propose the cleanest way to add [feature].
Preserve current behavior unless explicitly changed.
Call out the files that will likely need updates.
Use writing-plans to create an implementation plan for adding [feature] to this existing project.
Include scope, file-level changes, tests, and any risks.
Use executing-plans to implement the approved plan for [feature] in this existing project.
Make the smallest safe change, update tests, and avoid unrelated refactors.
Use systematic-debugging to find why [bug or failing behavior] is happening in this existing project.
Inspect the current code path first, identify the root cause, then fix it with minimal changes.

Parallel Subagent Prompt Template

Use this when the work can be split into independent parts:

Use dispatching-parallel-agents to work on this change.

Subagent 1: inspect [file/module A] and summarize the current behavior.
Subagent 2: inspect [file/module B] and identify the required changes.
Subagent 3: inspect the tests/docs and identify coverage or documentation updates.

Do not edit overlapping files.
Report findings first, then implement only within your assigned scope.

Guidelines for parallel work:

  • Give each subagent a distinct ownership area.
  • Keep file scopes disjoint to avoid merge conflicts.
  • Use parallel agents only for tasks that do not depend on each other.
  • If one task needs the result of another, do that part sequentially instead.

Skill Priority Rule

When multiple skills could apply, Codex follows this order:

  1. Process skills firstbrainstorming, systematic-debugging (determines how to approach)
  2. Implementation skills secondtest-driven-development, writing-plans (guides execution) superpowers:99-104

Citations

File: docs/README.codex.md (L52-58)

Codex has native skill discovery — it scans `~/.agents/skills/` at startup, parses SKILL.md frontmatter, and loads skills on demand. Superpowers skills are made visible through a single symlink:

~/.agents/skills/superpowers/ → ~/.codex/superpowers/skills/


The `using-superpowers` skill is discovered automatically and enforces skill usage discipline — no additional configuration needed.

File: docs/README.codex.md (L62-65)

Skills are discovered automatically. Codex activates them when:
- You mention a skill by name (e.g., "use brainstorming")
- The task matches a skill's description
- The `using-superpowers` skill directs Codex to use one

File: skills/using-superpowers/references/codex-tools.md (L5-14)

| Skill references | Codex equivalent |
|-----------------|------------------|
| `Task` tool (dispatch subagent) | `spawn_agent` (see [Named agent dispatch](#named-agent-dispatch)) |
| Multiple `Task` calls (parallel) | Multiple `spawn_agent` calls |
| Task returns result | `wait` |
| Task completes automatically | `close_agent` to free slot |
| `TodoWrite` (task tracking) | `update_plan` |
| `Skill` tool (invoke a skill) | Skills load natively — just follow the instructions |
| `Read`, `Write`, `Edit` (files) | Use your native file tools |
| `Bash` (run commands) | Use your native shell tools |

File: skills/using-superpowers/SKILL.md (L99-104)

When multiple skills could apply, use this order:

1. **Process skills first** (brainstorming, debugging) - these determine HOW to approach the task
2. **Implementation skills second** (frontend-design, mcp-builder) - these guide execution

"Let's build X" → brainstorming first, then implementation skills.

Use task-master with git branch

git checkout -b feature/lifecycle-mgmt

task-master tags add feature-lifecycle

task-master tags list

task-master tags use feature-lifecycle

task-master parse-prd .taskmaster/docs/lifecycle-management-prd.md --research

task-master expand --all --research

task-master list

1. Merge Git Branch

git checkout main git merge feature/lifecycle-mgmt

2. Archive the Task List

Switch back to master view in Task Master

task-master use tag master

(Optional) Archive the feature tag so it doesn't clutter your list

task-master archive tag feature-lifecycle

remote codespace activation Prompt: "Show me the options and start one" (Best for interactive agents) "I want to start a GitHub codespace but I don't remember its exact generated name. Please use gh codespace list --json name,displayName,repository to show me my current codespaces. Once I tell you which one I want, start it for me using gh codespace ssh -c -- echo 'UP'."

  • List Codespaces: Ran gh codespace list --json name,displayName,repository to find the exact ID of your available codespaces.
  • Identify Correct Command: Used gh codespace ssh which is the designated command to connect to a codespace.
  • Handle Automation: Executed gh codespace ssh -c <codespace_name> -- echo 'UP' where -c successfully specified the codespace target, and the command echo 'UP' verified the connection was live.
  • Result: The codespace automatically transitions from a "Shutdown" state to "Running" when the SSH command is initiated.
1. write a script for a bouncing yellow ball within a Rhombicosidodecahedron, make sure to handle collision detection properly. make the Rhombicosidodecahedron slowly rotate. make sure ball stays within the Rhombicosidodecahedron. implement it in p5.js and wrap it under html, so I can paste it to online html viewer
2. write a script for 100 bouncing bright yellow balls within a sphere, make sure to handle collision detection properly. make the sphere slowly rotate. make sure balls stays within the sphere. implement it in p5.js and wrap it under html, so I can paste it to online html viewer
3. write a html,css,jquery,p5.js program that shows a ball bouncing inside a spinning hexagon. The ball should be affected by gravity and friction, and it must bounce off the rotating walls realistically and wrap it under html so i can paste it.
4. use threejs make a fantastic 3d scene use your imagination more magic go all out and wrap it under html, so I can paste it to online html viewer
5. Create a single HTML file that uses Three.js to visualize a Rubik's Cube with realistic lighting and interactive controls. The cube should be built from 27 cubies with standard Rubik's Cube coloring. Include buttons for standard moves (U, U′, D, D′, L, L′, R, R′, F, F′, B, B′) that animate a 90° rotation on the appropriate face. Also, implement a scramble function that performs a series of random moves (recording each move), and an automatic unscrambler that, every 500 ms, applies the inverse of the recorded moves until the cube is solved. The solved state should be determined by comparing each cubie's current world position and rotation with its originally stored "solved" state (using a small tolerance) etc
6. Create a JavaScript animation of falling letters with realistic physics. The letters should: * Latters Should ‘Gajraj , Gajanan ,Gandev’ * Appear randomly at the top of the screen with varying sizes * Fall under Earth's gravity (9.8 m/s²) * Have collision detection based on their actual letter shapes * Interact with other letters, ground, and screen boundaries * Have density properties similar to water * Dynamically adapt to screen size changes * Display on a dark background and wrap it under html, so i can paste it to online html viewer
7. Build a p5js endless runner game with pixelated dinosaurs and interesting backgrounds.
8. Generate an HTML file that displays a colorful particle simulation of a reflection nebula.
9. Make a p5js simulation of 30 colorful boids swarming within a rotating hexagon.
10. Use p5js to explore a Mandelbrot set.
11. Develop a p5js demo of an interactive blend of fish and nebulae that visualizes what the fish are “thinking.”
12. In pure three.js, without downloading any assets or textures, create a flight simulator game where I can fly an airplane. Make sure it runs in the browser. (Corresponds to Flight Simulator Prompt description)
13. Write a p5.js script that simulates 25 particles in a vacuum space of a cylindrical container, bouncing within its boundaries. Use different colors for each ball and ensure they leave a trail showing their movement. Add a slow rotation of the container to give better view of what's going on in the scene. Make sure to create proper collision detection and physic rules to ensure particles remain in the container. Add an external spherical container. Add a slow zoom in and zoom out effect to the whole scene. (Corresponds to Particles in Cylinder description)
14. Generate an advanced p5.js simulation depicting multiple, mutually interacting balls subject to configurable gravity, air resistance, and inter-object friction, bouncing dynamically with accurate conservation of momentum within a continuously rotating regular hexagon whose vertices may subtly oscillate, ensuring physically precise collision detection and elastic/inelastic response against the moving, potentially deforming walls, and include interactive sliders controlling gravity strength, air resistance factor, hexagon angular velocity, vertex oscillation amplitude/frequency, ball elasticity (coefficient of restitution), and the initial number of balls. Single script. (Corresponds to Bouncing Balls Hexagon description)
15. Create an interactive simulation that shows water molecules forming and breaking hydrogen bonds. The visualization should depict molecular motion, with oxygen in white and hydrogen in red. A temperature slider should control movement speed and bond stability. Use HTML, CSS, and JavaScript in a single file for real-time interaction. (Corresponds to Water Molecule description)
16. Design a kaleidoscope using p5js that generates symmetrical patterns based on mouse movements.wrap it under html ,so I can paste it to online html viewer.
17. Create a rubik cube in p5.js ,I can play with it,you need to apply generator AND solver mode for this rubik cube,make sure wrap it in html one file,so i can paste it to online html viewer (Corresponds to prompt #4 in your final list)
18. Code a TV that lets me change channels with number keys (0-9). Come up with an idea for a channel for all numbers, inspired by classic genres of TV channels. Show detailed interesting animations for content and a creative name of channel on screen. Return a 800x800 P5.js sketch (no HTML) on black background. Make sure the content of all the channels stays masked to the TV set screen area,make sure wrap it in html one file,so i can paste it to online html viewer (Corresponds to prompt #5 in your final list)
19. make a app called chatgpt ad maker that takes in a video and does a halftone effect with sliders to adjust dot size and wrap it under html, so I can paste it to online html viewer
20. Build a Healthcare CRM to streamline patient communication, appointment scheduling, record management, and billing processes…,make sure wrap it in html one file,so i can paste it to online html viewer
21.
Write a complete HTML/JavaScript program using Three.js that renders a fully interactive Rubik's Cube simulation of any size up to 20x20x20. The user should be able to specify the cube size dynamically (e.g., via an input or a variable), and the cube should be constructed accordingly with proper color-coded faces (standard Rubik's Cube colors: white, yellow, red, orange, blue, green). Include camera controls for rotating the view, and allow for basic user interaction such as rotating layers of the cube via mouse or UI buttons.
Additionally, implement a "Solve" button that, when clicked, animates the cube being solved step-by-step visually. You can use a simplified solving algorithm (you do not need to match real Rubik's solving logic) - the goal is just to animate the cube returning to its original solved state, one move at a time, with clear transitions.
Requirements:
Use Three.js for all 3D rendering.
Cube size should be adjustable up to 20x20x20.
Solver animation should be smooth and readable.
Keep performance in mind for larger cubes (e.g., 20x20).
22.
Write code for - Generate self-contained HTML code (with embedded CSS and JavaScript) for an interactive web animation using pure HTML5 Canvas and JavaScript (no external libraries). The animation features a dynamic, large, white hexagonal maze on a solid black background, running continuously and smoothly. The canvas must resize to fill the entire browser window, with all elements scaling accordingly.
Important additional requirements: Each hexagon should apply circular rotation individually (i.e., each hexagon spins about its own center) and the animation must include a visible slider UI to control a global speed multiplier that scales the rotation speeds (and the outer gliding red line). Make the base rotation speeds noticeably faster than the original example so the rotation is visibly faster.
Maze Details:
Multiple (5) concentric white hexagonal outlines (layers), each rotating independently at increased random speeds and directions (use a faster base such as (Math.random() - 0.5) * 0.06 for each layer's angular velocity, and then multiply by the slider-controlled global speed multiplier). Each hexagon's rotation should be a true spin around the canvas center (circular rotation about its center). Random large gaps (1-2 per hexagon, excluding the outermost) in walls for ball passage. No internal connecting lines within any hexagonal layer (none of the concentric layers should have internal spokes or connecting lines).
Moving Elements:
Five small, brightly colored bouncing balls (red, green, blue, yellow, pink) moving independently with realistic physics: they bounce off maze walls (concentric outlines only, respecting all lines without crossing—use substeps and accurate collision detection for reliability). Balls should start near the center and maintain their assigned colors. A prominent red line glides clockwise along the outermost hexagon's perimeter (non-interacting with balls/maze); its path follows the outermost layer's rotation and is scaled by the same global speed multiplier.
Controls & UX:
Include a visible HTML range slider labeled "Rotation Speed" that controls a global speed multiplier (for example range 0.0 to 4.0, default 2.0) which scales the angular velocities of each hexagon and the outer glider. Show the slider value numerically next to the control. Place and style the slider so it remains visible and usable on all window sizes (e.g., top-left, semi-transparent background).
Implementation Details:
Implement drawing, rotation transforms, physics, collision detection, and animation loop using only the Canvas API and vanilla JavaScript. Ensure smooth resizing—when the window is resized the canvas and all geometry recalculate so the maze stays centered and scaled. Use sub-stepping for ball movement and collision resolution to prevent tunneling at higher speeds. The rotating hexagons must be drawn as outlines, rotate about the center, and respect gaps for ball passage. The red glider should move along the outer hexagon perimeter and be visually synced to its rotation. Ensure balls cannot cross hexagon walls (except through gaps). Ensure animation runs smoothly and is visibly faster due to the increased base speeds and the slider default.
Output the full complete HTML code (single file) that implements all of the above.
23.
Generate a 5x5 matrix filled with random numbers.Number must be between 1 to 10.Traverse the matrix in a spiral order, starting from the top-down corner and moving anti clockwise inward.Return the numbers from the matrix in a single line as output, representing the spiral traversal.without any coding.
24.
Can you create visual explanation in format of html + svg for following Description:
Take help of internet for latest information.As well apply Animation for batter understanding visual explanations
<description>
How LAN database Work
</description>
25.
Generate an animated SVG of a giraffe driving a tiny car
Generate an animated SVG of a frog on a vintage penny-farthing bicycle
Generate an animated SVG of pelican riding a bi-cycle on beach
With following factors keep in your mind
- you need to respect physics
- you need to cross-check it with ground reality in mind as near as possible.
- you need to align various parts or component with each other so it look real.
- you are going to execute entire plan with help of spawn multiple sub-agent .so you need to divide it in task,subtask,priority and generate dependency graph so you know about sequence of execution.
an otter on an airplane using wifi, on their laptop screen is image generation software creating an image of an otter on a plane using wifi
-----------------
Generated with Imagen 4 Fast
```
{ "scene": "minimalist white studio", "subjects": [ { "type": "smartwatch", "description": "silver frame with red strap", "position": "center", "pose": "lying flat" } ], "style": "photorealistic", "lighting": "diffused light from above", "mood": "clean and sleek", "background": "white gradient", "composition": "centered product with top view", "resolution": "4K" }
```
-----------------------
Prompt :
{
"shot": {
"composition": "medium shot, reporter on the left and baby on the right, both clearly framed at eye level",
"camera_motion": "static tripod shot, no zoom or pan",
"frame_rate": "30fps",
"film_grain": "soft hospital clarity, minimal grain"
},
"subject": {
"description": "male news reporter in a neat blue blazer holding a microphone labeled 'xyz' interviewing a newborn baby who is sitting upright on a hospital bed, wrapped in a white blanket",
"wardrobe": "reporter in blue blazer, white shirt, dark trousers"
},
"scene": {
"location": "hospital room with a bed, IV stand, and pale blue curtains",
"time_of_day": "daytime with fluorescent overhead lighting",
"environment": "sterile hospital look with subtle comedic undertone"
},
"visual_details": {
"action": "reporter leans slightly toward the sitting baby with a smile while holding the microphone, the baby shifts upright, glances at the reporter, then looks straight into the camera before delivering the line in a baby-like voice",
"props": "microphone with 'xyz' branding, baby sitting upright wrapped in soft white blanket, hospital bed with light green sheets"
},
"cinematography": {
"lighting": "flat fluorescent hospital lighting, evenly lit",
"tone": "comedic and satirical, staged like a serious news interview but with absurd content"
},
"audio": {
"ambient": "soft hospital background hum, faint beeping from a monitor",
"sfx": "slight mic handling noise when reporter shifts"
},
"color_palette": "clean whites, muted blues, soft green accents",
"dialogue": [
{
"character": "Reporter",
"line": "Welcome to the world. You're the smallest one in your family. What would you like to say?",
"subtitles": false
},
{
"character": "Baby",
"line": "Send me back. I heard my parents are poor.",
"voice_style": "natural baby voice with exaggerated clarity",
"subtitles": false
}
]
}

vibe-coding step-by-step guide:

  1. Write down a high-level plan
  2. Break it down into small phases
  3. Focus on one phase at a time

For each phase:

  1. Add as much context as possible to the plan
  2. Include the things you want to build
  3. Include the things you don't want to build
  4. Commit your code
  5. Give the plan to the agent to start building

For each iteration of the agent:

  1. Review everything the agent built
  2. Provide clear feedback for refinements
  3. Update the plan with your feedback
  4. Discard code and restart anytime the agent messes up

As I build critical functionality:

  1. Write unit tests for any critical piece of code
  2. Ensure these tests run after each agent iteration

Tips:

✦ You are right to point this out, and I appreciate you asking for clarification. It helps us work better together. The issue stems from a combination of how I interpreted the prompt and the strong influence of the reference file.

Here is a breakdown of the reason for the discrepancy:

  1. Influence of the Reference File (sample.py): The sample.py file implemented a command-line interface where the user had to know the specific command to type (e.g., upload_file_to_s3('~/Pictures/cat.png')). My primary goal was to replicate that functionality in main.py based on your instructions. I interpreted "move related logic and interaction with end user to main.py files" as "make main.py work like sample.py."

  2. Ambiguity in "Ask for File Uploads": This is the core of the misunderstanding.

    • My Interpretation: I interpreted "ask" as "provide a mechanism for the user to initiate an upload." In a CLI context, this often means printing instructions on how to use a command, which is what I did (print(" - upload <path_to_file>")). I made it a user-initiated command.
    • Your Likely Intent: You likely meant for the program to be more proactive and literally ask a question to the user, such as Would you like to upload a file? (y/n). This is a more interactive and guided approach.

What was missed was the style of interaction you wanted. I implemented the feature functionally, but not with the user-friendly, interactive flow you had in mind.

How to Improve Our Collaboration (What I need from you next time):

To prevent this in the future, it would be incredibly helpful if you could be more specific about the user interaction flow. For example, instead of:

"you need to ask file uploads and take physical file path as input parameter"

A more precise prompt would be:

"When the script starts, interactively prompt the user with the question 'Would you like to upload a file?'. If they say yes, then prompt them for the file path. The file upload should happen before they start chatting with the agent."

By being more explicit about the desired dialogue or sequence of events, you can help me bridge the gap between a functional implementation and the exact user experience you envision.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment