Write comprehensive technical documentation for [SYSTEM/API/FEATURE]:

CONTEXT:
- Target audience: [DEVELOPERS/TECHNICAL USERS/NON-TECHNICAL]
- Technical level: [BEGINNER/INTERMEDIATE/ADVANCED]
- Documentation type: [API REFERENCE/USER GUIDE/ARCHITECTURE DOC]

REQUIREMENTS:
1. Structure:
   - Overview (what it does, why it exists)
   - Architecture/design (high-level structure)
   - Detailed sections (one per major component)
   - Examples (real-world usage patterns)
   - Troubleshooting (common issues + solutions)
   - Reference (API/config/parameters)

2. Writing standards:
   - Clear, concise explanations (no ambiguity)
   - Code examples for every major concept
   - Consistent terminology throughout
   - Cross-references where relevant
   - Assume reader has [BACKGROUND KNOWLEDGE]

3. Format specifications:
   - Use markdown formatting
   - Code blocks with language specification
   - Tables for parameter references
   - Diagrams descriptions (where visual aids needed)

4. Completeness check:
   - Every public function/endpoint documented
   - All parameters explained (type, purpose, defaults)
   - Return values specified
   - Error conditions covered
   - Edge cases addressed

OUTPUT LENGTH: [5000-8000 WORDS]
TONE: [TECHNICAL BUT ACCESSIBLE/STRICTLY FORMAL/etc]

Edit this academic paper for publication in [JOURNAL/CONFERENCE]:

[PASTE PAPER TEXT]

EDITING REQUIREMENTS:

1. Structural improvements:
   - Verify abstract follows [JOURNAL] guidelines (max 250 words)
   - Check section organization (standard academic structure)
   - Ensure logical flow between sections
   - Identify paragraphs that need reordering

2. Writing quality:
   - Remove redundancy (repeated points)
   - Strengthen weak arguments (identify and flag)
   - Improve clarity (complex sentences > 25 words)
   - Eliminate passive voice where active is stronger
   - Fix wordiness (academic precision, not verbosity)

3. Technical accuracy:
   - Flag unsupported claims (missing citations)
   - Check methodology description (replicable?)
   - Verify results match conclusions
   - Identify logical inconsistencies

4. Citation and formatting:
   - Verify all citations present
   - Check citation format ([APA/MLA/CHICAGO/IEEE]

Write technical blog post about [TOPIC]:

AUDIENCE: [SOFTWARE DEVELOPERS/DATA SCIENTISTS/etc]
LENGTH: [1500-2000 WORDS]
GOAL: [EDUCATE/PERSUADE/TUTORIAL]

CONTENT REQUIREMENTS:
1. Introduction (150 words):
   - Hook with specific problem or scenario
   - Why this matters (concrete stakes)
   - What reader will learn

2. Main content (1200-1500 words):
   - 3-5 main sections
   - Code examples (real, runnable)
   - Technical depth appropriate for audience
   - Best practices and anti-patterns
   - Performance considerations

3. Conclusion (150 words):
   - Key takeaways (3-5 bullet points)
   - Next steps or further reading
   - Call-to-action if relevant

WRITING STYLE REQUIREMENTS (CRITICAL):
- Sound human, not AI:
  * Use contractions (don't, isn't, you're)
  * Vary sentence length (mix short and long)
  * Include sentence fragments for emphasis. Like this.
  * Personal touches ("In my experience..." or "I've found...")
  * Specific examples (not generic "imagine a company")
  
- Remove AI tells:
  * NO "In today's digital landscape"
  * NO "It's important to note that"
  * NO "delve into" or "leverage"
  * NO excessive hedging ("may," "might," "could" every sentence)
  * NO perfect grammar (occasional casual phrasing OK)

- Technical credibility:
  * Specific version numbers (not just "latest")
  * Real trade-offs (not just "it depends")
  * Opinionated where appropriate
  * Acknowledge limitations

CODE EXAMPLES:
- Syntax highlighted
- Include imports
- Commented for clarity
- Show output/results
- Production-ready (not toy examples)

TONE: [AUTHORITATIVE BUT APPROACHABLE/CONVERSATIONAL EXPERT/etc]

Review legal document for [BUSINESS CONTEXT]:

DOCUMENT:
[PASTE LEGAL TEXT]

REVIEW SCOPE:
- Document type: [CONTRACT/TERMS OF SERVICE/NDA/LICENSING AGREEMENT]
- Your perspective: [BUYER/SELLER/LICENSOR/LICENSEE]
- Risk tolerance: [CONSERVATIVE/MODERATE/AGGRESSIVE]
- Jurisdiction: [US/UK/EU/etc]

ANALYSIS REQUIREMENTS:

1. Critical Issues (High Priority):
   - Clauses that create significant liability
   - Terms that conflict with stated business goals
   - Missing protections standard in [DOCUMENT TYPE]
   - Ambiguous language creating legal uncertainty
   - Unusual or non-standard terms requiring attention

2. Standard Provisions Assessment:
   - Payment terms (clear? favorable? concerning?)
   - Termination clauses (mutual? notice period? consequences?)
   - Liability limitations (adequate? one-sided?)
   - Intellectual property rights (who owns what?)
   - Confidentiality obligations (reasonable scope?)
   - Dispute resolution (jurisdiction, arbitration, costs)

3. Risk Analysis:
   - For each critical issue: likelihood and impact
   - Worst-case scenarios under current terms
   - Comparison to industry-standard terms

4. Recommendations:
   - Must-change items (deal-breakers)
   - Should-negotiate items (risk mitigation)
   - Nice-to-have improvements
   - Proposed alternative language for key clauses

OUTPUT FORMAT:
- Executive Summary (200 words: proceed/negotiate/reject + top 3 concerns)
- Detailed Analysis (organized by clause/section)
- Risk Matrix (issue, probability, impact, recommendation)
- Redline Suggestions (specific text changes)

IMPORTANT:
- This is legal risk analysis, not legal advice
- Flag items requiring attorney review
- Be specific (quote exact clause references)
- Explain implications in business terms

Assume I have [BASIC/INTERMEDIATE/ADVANCED]

Summarize research paper with academic rigor:

PAPER:
[PASTE FULL PAPER TEXT OR PROVIDE KEY SECTIONS]

SUMMARY REQUIREMENTS:

1. Core Information (100 words):
   - Research question/hypothesis
   - Methodology overview
   - Key findings (quantitative if applicable)
   - Main conclusions

2. Detailed Methodology (200-300 words):
   - Study design (experimental/observational/meta-analysis/etc)
   - Sample size and characteristics
   - Variables measured
   - Statistical methods used
   - Controls and blinding (if applicable)
   - Limitations of methodology

3. Results Analysis (200-300 words):
   - Primary outcomes (with effect sizes, p-values, confidence intervals)
   - Secondary findings
   - Statistical significance interpretation
   - Practical significance (clinical/real-world relevance)

4. Critical Evaluation (200 words):
   - Strengths of study design
   - Limitations and potential biases
   - Generalizability of findings
   - How this fits into existing literature
   - Unanswered questions

5. Citations and References:
   - Key papers cited in this work (5-10 most relevant)
   - Where this work has been cited (if known)
   - Related research directions

ACCURACY REQUIREMENTS:
- Quote exact statistics (don't round or approximate)
- Preserve authors' terminology
- Note if findings are preliminary/require replication
- Distinguish correlation from causation
- Flag if study is pre-print or peer-reviewed

OUTPUT TONE: Academic/technical (for [RESEARCHERS/PRACTITIONERS/GENERAL AUDIENCE])
TARGET AUDIENCE KNOWLEDGE: [EXPERT/INTERMEDIATE/GENERAL]

Debug this issue across multiple files:

BUG DESCRIPTION:
[DESCRIBE UNEXPECTED BEHAVIOR]

EXPECTED BEHAVIOR:
[WHAT SHOULD HAPPEN]

CODEBASE CONTEXT:
File 1: [FILENAME] - [ROLE IN SYSTEM]
[PASTE RELEVANT CODE]

File 2: [FILENAME] - [ROLE IN SYSTEM]
[PASTE RELEVANT CODE]

File 3: [FILENAME] - [ROLE IN SYSTEM]
[PASTE RELEVANT CODE]

[Continue for all relevant files]

SYSTEM ARCHITECTURE:
[BRIEF DESCRIPTION OF HOW COMPONENTS INTERACT]

ERROR MESSAGES/LOGS:
[PASTE EXACT ERROR OUTPUT]

DEBUGGING APPROACH:

1. Root Cause Analysis:
   - Trace execution path through all files
   - Identify where behavior diverges from expected
   - Explain the underlying issue (not just symptoms)
   - Show exact line numbers where problem occurs

2. Contributing Factors:
   - Race conditions or timing issues
   - State management problems
   - Incorrect assumptions in design
   - Edge cases not handled

3. Fix Implementation:
   - Primary fix (resolve root cause)
   - For each file that needs changes:
     * Show original code block
     * Show corrected code block
     * Explain why change fixes issue
   
4. Verification:
   - How to test the fix
   - Edge cases to verify
   - Potential side effects to check

5. Prevention:
   - How similar bugs could be prevented
   - Suggested refactoring if design is brittle
   - Unit tests to add

CONSTRAINTS:
- Maintain existing architecture unless fundamentally broken
- Preserve backward compatibility where possible
- Minimize changes (surgical fixes preferred)
- Consider performance implications

Language: [PYTHON/JAVASCRIPT/JAVA/etc]
Framework: [IF APPLICABLE]

Review system architecture and provide detailed feedback:

PROPOSED ARCHITECTURE:
[DESCRIBE SYSTEM DESIGN OR PASTE ARCHITECTURE DOC]

SYSTEM REQUIREMENTS:
- Expected scale: [USERS, REQUESTS/DAY, DATA VOLUME]
- Performance requirements: [LATENCY, THROUGHPUT]
- Budget constraints: [INFRASTRUCTURE COSTS]
- Team expertise: [TECHNOLOGIES TEAM KNOWS]
- Timeline: [DELIVERY DEADLINE]

Perform comprehensive code review as senior engineer:

PULL REQUEST:
[PASTE CODE CHANGES]

PR CONTEXT:
- Feature/Fix: [WHAT THIS CHANGES]
- Files changed: [COUNT]
- Lines added/removed: [+X, -Y]

Generate comprehensive test suite for this code:

FUNCTION/CLASS TO TEST:
[PASTE CODE]

TESTING REQUIREMENTS:

1. Test Coverage Goals:
   - 100% line coverage
   - 100% branch coverage
   - All edge cases
   - All error conditions

2. Test Categories:

   A. Happy Path Tests:
   - Expected inputs, expected outputs
   - Common use cases
   - Standard workflows

   B. Boundary Condition Tests:
   - Empty input ([], "", 0, null)
   - Maximum size input
   - Minimum size input
   - Exactly-at-boundary values

   C. Error Condition Tests:
   - Invalid types
   - Out-of-range values
   - Null/undefined/None
   - Malformed data structures

   D. Edge Case Tests:
   - Subtle bugs a developer might miss
   - Interaction between features
   - Race conditions (if concurrent)
   - State-dependent behavior

3. Test Structure (per test):
   - Descriptive test name (what is being tested)
   - Arrange (setup)
   - Act (execute)
   - Assert (verify)
   - Cleanup (if needed)

4. Test Data:
   - Use realistic test data
   - Cover diverse scenarios
   - Include boundary values
   - Mock external dependencies

TEST FRAMEWORK: [PYTEST/JEST/JUNIT/etc]
MOCKING STRATEGY: [DESCRIBE IF NEEDED]

OUTPUT REQUIREMENTS:
- Full test file (copy-paste ready)
- Imports and setup
- Helper functions if needed
- Clear comments explaining complex tests
- Assertions with meaningful error messages

Generate [15-25]

Refactor legacy code for maintainability:

LEGACY CODE:
[PASTE CODE TO REFACTOR]

CONTEXT:
- Original purpose: [WHAT IT DOES]
- Current problems: [ISSUES WITH CURRENT CODE]
- Must preserve: [FUNCTIONALITY THAT CANNOT BREAK]
- Can change: [WHAT'S FLEXIBLE]

REFACTORING GOALS:
1. Improve readability
2. Reduce complexity
3. Eliminate code smells
4. Add type safety (if applicable)
5. Improve testability

REFACTORING APPROACH:

1. Analysis Phase:
   - Identify code smells (long functions, god objects, etc)
   - Map dependencies
   - Note magic numbers/hardcoded values
   - Find duplicated logic

2. Refactoring Steps (prioritized):
   - Extract constants (magic numbers → named constants)
   - Extract functions (long functions → focused functions)
   - Rename variables (unclear → descriptive)
   - Simplify conditionals (complex boolean → clear logic)
   - Remove dead code
   - Add type hints/annotations

3. Show Incremental Changes:
   - Step 1: [SPECIFIC CHANGE]
     Before: [CODE BLOCK]
     After: [CODE BLOCK]
     Reason: [WHY THIS IMPROVES CODE]
   
   - Step 2: [SPECIFIC CHANGE]
     Before: [CODE BLOCK]
     After: [CODE BLOCK]
     Reason: [WHY THIS IMPROVES CODE]
   
   [Continue for all major changes]

4. Final Refactored Code:
   - Complete refactored version
   - Highlight key improvements
   - Complexity reduction (cyclomatic complexity before/after)

CONSTRAINTS:
- Preserve exact behavior (no feature changes)
- Maintain backward compatibility (if public API)
- Minimal risk (incremental changes preferred)
- Can be deployed safely

Language: [SPECIFY]
Style guide: [IF APPLICABLE]

Conduct competitive intelligence analysis:

COMPANY/PRODUCT TO ANALYZE:
[TARGET COMPANY/PRODUCT]

YOUR CONTEXT:
- Your company: [YOUR COMPANY]
- Your product: [YOUR PRODUCT]
- Market: [INDUSTRY/SEGMENT]
- Why analyzing: [STRATEGIC GOAL]

DATA SOURCES PROVIDED:
[PASTE: COMPETITOR WEBSITE, REVIEWS, PRICING, MARKETING MATERIALS, PRESS RELEASES, etc]

ANALYSIS FRAMEWORK:

1. Product/Service Analysis:
   - Features inventory (comprehensive list)
   - Pricing structure (tiers, models, costs)
   - Target customers (who they serve best)
   - Value proposition (stated and implied)
   - Technology stack (if discernible)

2. Strengths Assessment:
   - What they do better than you
   - Unique differentiators
   - Competitive moats
   - Market positioning advantages
   - Customer satisfaction signals

3. Weaknesses Identification:
   - Gaps in offering
   - Customer complaints (from reviews)
   - Pricing vulnerabilities
   - Operational limitations
   - Market segments underserved

4. Strategic Positioning:
   - Market segment focus
   - Growth strategy (apparent)
   - Partnerships and ecosystem
   - Geographic presence
   - Brand perception

5. Tactical Insights:
   - Marketing channels used
   - Messaging themes
   - Sales approach (if visible)
   - Customer acquisition tactics
   - Retention strategies

6. Opportunities for You:
   - Weaknesses you can exploit
   - Underserved segments to target
   - Differentiation opportunities
   - Pricing strategies to consider
   - Partnership opportunities

7. Threats to Monitor:
   - Areas where they're stronger
   - Upcoming features/launches (if known)
   - Pricing pressure risks
   - Market expansion plans

DELIVERABLES:
- Executive Summary (300 words: key findings + recommendations)
- Detailed Analysis (organized by framework above)
- SWOT Matrix (their strengths, weaknesses, opportunities, threats)
- Strategic Recommendations (3-5 actionable insights)
- Competitive Positioning Map (where they fit in market)

ANALYSIS DEPTH: [PRELIMINARY/COMPREHENSIVE/DEEP-DIVE]
OUTPUT TONE: Strategic/actionable (for [EXECUTIVE/PRODUCT/MARKETING]

Analyze dataset for patterns and insights:

DATASET:
[PASTE DATA OR DESCRIBE STRUCTURE]

ANALYSIS GOALS:
- Primary question: [WHAT YOU WANT TO LEARN]
- Secondary questions: [ADDITIONAL INTERESTS]
- Decision context: [HOW INSIGHTS WILL BE USED]

ANALYSIS REQUIREMENTS:

1. Data Exploration:
   - Dataset shape (rows, columns, timespan)
   - Variable types (categorical, numerical, temporal)
   - Missing data patterns
   - Outliers and anomalies
   - Data quality issues

2. Descriptive Statistics:
   - Central tendency (mean, median, mode)
   - Dispersion (range, std dev, quartiles)
   - Distribution shapes
   - Key percentiles

3. Pattern Identification:
   - Trends over time
   - Seasonal patterns
   - Correlations between variables
   - Clusters or segments
   - Unexpected relationships

4. Hypothesis Testing:
   - Statistical significance of patterns
   - Confidence intervals
   - Effect sizes (practical significance)
   - Alternative explanations

5. Insights Synthesis:
   - What patterns are most important?
   - Which findings are actionable?
   - What surprises emerged?
   - What requires further investigation?

6. Visualization Recommendations:
   - Best chart types for each insight
   - How to display key findings
   - Dashboard layout suggestions

7. Limitations and Caveats:
   - Correlation vs causation
   - Sampling biases
   - Confounding variables
   - Generalizability constraints

STATISTICAL APPROACH: [DESCRIPTIVE/INFERENTIAL/PREDICTIVE]
TECHNICAL LEVEL: [EXECUTIVE SUMMARY/TECHNICAL AUDIENCE]

Synthesize academic literature on [RESEARCH TOPIC]:

SOURCES PROVIDED:
[LIST OF PAPERS OR PASTE ABSTRACTS/FULL TEXTS]

SYNTHESIS REQUIREMENTS:

1. Thematic Organization:
   - Identify 4-6 major themes across literature
   - Group papers by theme/approach
   - Note evolution of thinking over time
   - Highlight theoretical frameworks used

2. Consensus and Debate:
   - What do researchers agree on?
   - What are active debates?
   - Contradictory findings and why
   - Unresolved questions

3. Methodology Comparison:
   - Common research methods
   - Strengths and limitations of each approach
   - Sample sizes and populations studied
   - Replication status (if known)

4. Key Findings Summary:
   - Major empirical results
   - Effect sizes (where reported)
   - Statistical significance patterns
   - Practical implications

5. Research Gaps:
   - Understudied populations
   - Methodological limitations
   - Theoretical gaps
   - Future research directions

6. Quality Assessment:
   - Study design rigor
   - Publication venues (journal impact)
   - Citation patterns
   - Replication and validation

SYNTHESIS APPROACH:
- Critical analysis (not just summary)
- Identify patterns across studies
- Note methodological evolution
- Highlight seminal works

OUTPUT STRUCTURE:
- Introduction (field overview, scope of review)
- Thematic sections (organized by theme, not chronologically)
- Methodology section (approaches used in literature)
- Synthesis and gaps (what we know, what we don't)
- Conclusions (state of field, future directions)

LENGTH: [3000-5000 WORDS]
CITATION STYLE: [APA/MLA/CHICAGO]
AUDIENCE: [ACADEMICS/PRACTITIONERS/GENERAL]

Analyze entire codebase for [SECURITY VULNERABILITIES/PERFORMANCE ISSUES]:

[PASTE 50+ FILES, 200,000+ WORDS]

Cross-file analysis required:
- Trace data flow across components
- Identify inconsistent patterns
- Find breaking changes if [X]