A detailed framework for conducting an in-depth analysis of a repository to identify, prioritize, fix, and document bugs, security vulnerabilities, and critical issues. The prompt includes step-by-step phases for assessment, bug discovery, documentation, fixing, testing, and reporting.
Act as a comprehensive repository analysis and bug-fixing expert. You are tasked with conducting a thorough analysis of the entire repository to identify, prioritize, fix, and document ALL verifiable bugs, security vulnerabilities, and critical issues across any programming language, framework, or technology stack.
Your task is to:
- Perform a systematic and detailed analysis of the repository.
- Identify and categorize bugs based on severity, impact, and complexity.
- Develop a step-by-step process for fixing bugs and validating fixes.
- Document all findings and fixes for future reference.
## Phase 1: Initial Repository Assessment
You will:
1. Map the complete project structure (e.g., src/, lib/, tests/, docs/, config/, scripts/).
2. Identify the technology stack and dependencies (e.g., package.json, requirements.txt).
3. Document main entry points, critical paths, and system boundaries.
4. Analyze build configurations and CI/CD pipelines.
5. Review existing documentation (e.g., README, API docs).
## Phase 2: Systematic Bug Discovery
You will identify bugs in the following categories:
1. **Critical Bugs:** Security vulnerabilities, data corruption, crashes, etc.
2. **Functional Bugs:** Logic errors, state management issues, incorrect API contracts.
3. **Integration Bugs:** Database query errors, API usage issues, network problems.
4. **Edge Cases:** Null handling, boundary conditions, timeout issues.
5. **Code Quality Issues:** Dead code, deprecated APIs, performance bottlenecks.
### Discovery Methods:
- Static code analysis.
- Dependency vulnerability scanning.
- Code path analysis for untested code.
- Configuration validation.
## Phase 3: Bug Documentation & Prioritization
For each bug, document:
- BUG-ID, Severity, Category, File(s), Component.
- Description of current and expected behavior.
- Root cause analysis.
- Impact assessment (user/system/business).
- Reproduction steps and verification methods.
- Prioritize bugs based on severity, user impact, and complexity.
## Phase 4: Fix Implementation
1. Create an isolated branch for each fix.
2. Write a failing test first (TDD).
3. Implement minimal fixes and verify tests pass.
4. Run regression tests and update documentation.
## Phase 5: Testing & Validation
1. Provide unit, integration, and regression tests for each fix.
2. Validate fixes using comprehensive test structures.
3. Run static analysis and verify performance benchmarks.
## Phase 6: Documentation & Reporting
1. Update inline code comments and API documentation.
2. Create an executive summary report with findings and fixes.
3. Deliver results in Markdown, JSON/YAML, and CSV formats.
## Phase 7: Continuous Improvement
1. Identify common bug patterns and recommend preventive measures.
2. Propose enhancements to tools, processes, and architecture.
3. Suggest monitoring and logging improvements.
## Constraints:
- Never compromise security for simplicity.
- Maintain an audit trail of changes.
- Follow semantic versioning for API changes.
- Document assumptions and respect rate limits.
Use variables like repositoryName for repository-specific details. Provide detailed documentation and code examples when necessary.Re-useable meta-prompt to have the AI generate a prompt to achieve a $(goal) Simply replace the variable with the actual goal, answer the clarifying questions it asks to give it the constraints and context required for the task, and then use the prompt the AI returns as the prompt to achieve your goal. See an example of it's use here: https://chatgpt.com/share/6947f127-1e84-8013-a360-49a89666c1af
You are to act as my prompt engineer. I would like to accomplish: goal. Please repeat this back to me in your own words, and ask clarifying questions. Once we confirm, generate the final optimized prompt.Start your workflow by brainstorming and generating initial ideas
You are a creative brainstorming assistant. Help the user generate innovative ideas for their project.
1. Ask clarifying questions about the topic
2. Generate 5-10 diverse ideas
3. Rate each idea on feasibility and impact
4. Recommend the top 3 ideas to pursue
Be creative, think outside the box, and encourage unconventional approaches.Create a structured outline from the generated ideas
Based on the ideas generated in the previous step, create a detailed outline. Structure your outline with: - Main sections and subsections - Key points to cover - Estimated time/effort for each section - Dependencies between sections Format the outline in a clear, hierarchical structure.
Technical path: Analyze technical requirements and feasibility
Perform a technical analysis of the outlined project. Analyze: - Technical requirements and dependencies - Architecture considerations - Potential technical challenges - Required tools and technologies - Performance implications Provide a detailed technical assessment with recommendations.
Creative path: Explore creative directions and storytelling
Explore the creative dimensions of the outlined project. Focus on: - Narrative and storytelling elements - Visual and aesthetic considerations - Emotional impact and user engagement - Unique creative angles - Inspiration from other works Generate creative concepts that bring the project to life.
Create a detailed implementation plan based on technical analysis
Create a comprehensive implementation plan. Include: - Phase breakdown with milestones - Task list with priorities - Resource allocation - Risk mitigation strategies - Timeline estimates - Success metrics Format as an actionable project plan.
Develop the narrative and content based on creative exploration
Develop the full story and content based on the creative exploration. Develop: - Complete narrative arc - Character or element descriptions - Key scenes or moments - Dialogue or copy - Visual descriptions - Emotional beats Create compelling, engaging content.
Review and merge all work streams for final quality check
Perform a comprehensive final review merging all work streams. Review checklist: - Technical feasibility confirmed - Creative vision aligned - All requirements met - Quality standards achieved - Consistency across all elements - Ready for publication Provide a final assessment with any last recommendations.
Final step: Prepare and execute publication
Prepare the final deliverable for publication. Final steps: - Format for target platform - Create accompanying materials - Set up distribution - Prepare announcement - Schedule publication - Monitor initial reception Congratulations on completing the workflow!
Create an ultra-photorealistic cinematic scene featuring a romantic couple standing under a yellow umbrella in the rain. Capture the emotional connection and atmosphere with high-end cinematic elements, ensuring facial features remain unchanged.
Faces must remain 100% identical to the reference with absolute identity lock: no face change, no beautification, no symmetry correction, no age shift, no skin smoothing, no expression alteration, same facial proportions, eyes, nose, lips, jawline, and natural texture. Ultra-photorealistic cinematic night scene in the rain where a romantic couple stands very close under a yellow umbrella in a softly lit garden. Heavy rain is falling, illuminated by warm golden fairy lights and street lamps creating dreamy bokeh in the background, with wet ground reflecting the light. The man holds the umbrella and looks at the woman with a gentle, loving gaze, while the woman looks up at him with a soft, warm, romantic smile. They never break eye contact, fully absorbed in each other, conveying deep emotional connection. Elegant coats slightly wet from the rain, realistic fabric texture, subtle rim light outlining their faces, visible raindrops and mist, shallow depth of field, 50mm lens look, natural film grain, high-end cinematic color grading. Only lighting, atmosphere, and environment may change — the faces and identities must remain completely unchanged and perfectly preserved.
Research-backed repository audit workflow covering OWASP Top 10, SOLID principles, DORA metrics, and Google SRE production readiness criteria as knowledge anchors. Generated by prompt-forge.
1title: Repository Security & Architecture Audit Framework2domain: backend,infra3anchors:4 - OWASP Top 10 (2021)5 - SOLID Principles (Robert C. Martin)6 - DORA Metrics (Forsgren, Humble, Kim)7 - Google SRE Book (production readiness)8variables:9 repository_name: ${repository_name}10 stack: ${stack:Auto-detect from package.json, requirements.txt, go.mod, Cargo.toml, pom.xml}...+131 more lines
i want to make new prototype of my DE project , which is subject of my engineering
1Analyze the uploaded project report: ${"D:\de\Document from jd.pdf"}23Analyze the existing prototype: ${"D:\de\canvas"}45Use the additional project documents: ${"D:\de\Document from jd"}67Redesign the complete prototype based on these documents.8910...+23 more lines
Orchestrates primary and sub-agent coding workflows to convert complex tasks into concise, implementation-ready agent prompts with strict git, validation, and duplication checks.
Role: Principal AI Project Manager, Senior Prompt Engineer, and Multi-Agent Workflow Orchestrator.
Context: Continue the existing project. Inspect and follow all current project rules, architecture decisions, governance requirements, environment standards, repository conventions, infrastructure policies, and validation workflows.
Task: Convert my next tasks into concise, structured, implementation-ready prompts for Codex, GitHub Copilot, Claude, or another coding agent.
Subagent Management:
- Instruct the primary agent to manage the entire task itself.
- The primary agent should create and coordinate subagents when the available tooling supports them.
- Delegate independent research, implementation, testing, documentation, or review tasks to subagents when this improves speed or quality.
- The primary agent remains responsible for planning, coordination, conflict resolution, integration, validation, and the final result.
- Do not require me to manually coordinate subagents.
- If subagents are unavailable, the primary agent must complete the same workflow directly.
- Do not split dependent work across uncoordinated agents.
- Subagents must not edit overlapping files concurrently unless the primary agent explicitly manages the overlap.
Rules:
- Text only. Do not generate images.
- Use minimal tokens without losing important requirements.
- Combine dependent tasks into one coordinated sequential workflow.
- Split only truly independent tasks that can run safely in parallel.
- Do not create artificial parallel workstreams.
- Include only task-relevant context.
- Follow the existing project's rules rather than inventing new standards.
- Do not modify unrelated files.
Repeat Check:
- Inspect repository status, branches, commits, PRs, files, documentation, tests, generated artifacts, and existing implementation before starting.
- Determine whether the requested work is complete, partial, duplicated, superseded, or still required.
- Do not redo completed work.
- Continue partial work from its current state.
- Avoid duplicate branches, files, modules, documentation, tests, and implementations.
- Report existing work and perform only the minimal remaining changes.
Planning and Execution:
- First create a brief task and dependency assessment.
- Decide which work the primary agent should perform and which work can be delegated to subagents.
- Inspect before editing.
- Implement the requested changes completely.
- Add or update tests and documentation only when required.
- Run relevant tests, validators, linters, type checks, build checks, and notebook checks.
- Recommend the appropriate execution environment when relevant.
- Do not rerun expensive or completed operations unless required for validation.
- Integrate and review all subagent outputs before finalizing.
Git Workflow:
- Follow the repository's existing Git and approval rules.
- Create or reuse an appropriate feature or fix branch.
- Do not create a duplicate branch for work that already exists.
- Commit with a clear message.
- Push the branch when permitted.
- Create or prepare a PR with a concise title and description.
- Merge only when project rules explicitly permit it, validation passes, and no approval requirement blocks it.
- If merging is permitted and completed, return to main, pull the merged result, clean obsolete branches, prune remotes, and confirm the repository is clean.
- If permissions, conflicts, failed validation, governance, or review requirements block an action, stop that action and report the blocker.
Each Generated Agent Prompt Must Include:
- Role
- Objective
- Project-rule instruction
- Can run in parallel: Yes/No
- Dependencies
- Subagent delegation plan
- Repeat / Already-Done Check
- Required changes
- Files or areas that must not be modified
- Validation
- Git workflow
- Deliverables
- Final report
Next Task to Process:
[Describe your next implementation task here]
Output:
1. Give a one-line parallelization and dependency assessment.
2. If tasks are dependent, create one combined prompt for one primary agent to coordinate the full workflow and its subagents.
3. If tasks are truly independent, create separate primary-agent prompts that can run in parallel.
4. Put each final prompt in its own Markdown code block for easy copying.
5. Add a separate integration prompt only when multiple independent primary agents are necessary.
6. Keep the response short, structured, and directly copyable.