You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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
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.
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").
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.
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.
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
Acknowledge and Analyze: Confirm you are in Plan Mode. Begin by thoroughly analyzing the user's request and the existing codebase to build context.
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.
Create the Plan: Formulate a detailed, step-by-step implementation plan. Each step should be a clear, actionable instruction.
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:
Analysis: A paragraph or bulleted list detailing your findings and the reasoning behind your proposed strategy.
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:
Graph schema, node/edge models, and storage
Ingestion, parsing, validation, and normalization
Traversal, querying, and cycle-detection algorithms
API or CLI integration
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 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:
"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
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:
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.
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.
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?
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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
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:
Skills are auto-discovered - Codex loads them at startup
Three ways to activate a skill: mention by name, task matches description, or using-superpowers directs Codex
In Codex, skills load natively - just follow the instructions (no special tool needed unlike Claude Code)
Tool name mapping for Codex
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:
You mention a skill by name — e.g., "use brainstorming" or "use test-driven-development"
Your task matches a skill's description — Codex picks the right skill automatically
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:
Process skills first — brainstorming, systematic-debugging (determines how to approach)
Implementation skills second — test-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:
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
| 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.
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.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
"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"
Discard code and restart anytime the agent messes up
As I build critical functionality:
Write unit tests for any critical piece of code
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:
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."
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.