Create a high-impact showcase and analysis of a website, product, service, project, company, invention, or system.

/showcase https://example.com

Typical output should cover:

* What it is * Target market * Key features * Unique selling points * Competitive advantages * Weaknesses * Missing information * Trust signals * Conversion effectiveness * SEO * Mobile presentation * Calls to action * Commercial potential * Recommended improvements

Example:

/showcase https://maree-careflow.com.au

Analyse a website/product and create a Meta/Facebook/Instagram advertising strategy.

/metaads https://example.com

Expected areas:

* Campaign structure * Target audiences * Customer personas * Ad angles * Hooks * Headlines * Primary text * Calls to action * Creative concepts * Retargeting * Lead-generation strategy * Landing-page alignment * Conversion optimisation * A/B tests

Create or describe an exploded technical view showing the components of an object separated into logical layers/components.

/explodedview [OBJECT]

Examples:

/explodedview roller-coaster
/explodedview keyboard 101
/explodedview Haval H6
/explodedview brain
/explodedview BBQ

Useful additions:

/explodedview [OBJECT] photorealistic
/explodedview [OBJECT] engineering diagram
/explodedview [OBJECT] labelled
/explodedview [OBJECT] transparent casing
/explodedview [OBJECT] all major and minor components

Request a detailed, source-backed investigation.

/deepresearch [QUESTION]

Better:

/deepresearch

SUBJECT:
[subject]

OBJECTIVE:
[what I need to establish]

COUNTRY/JURISDICTION:
Australia

REQUIREMENTS:

* Current information
* Primary sources first
* Cross-check important claims
* Separate fact from assumption
* Give source links
* State uncertainties

  

Aggressively verify a claim.

/factcheck [CLAIM]

Example:

/factcheck
MareeDB is the fastest multimodel database currently available.

Best result should distinguish:

* Confirmed * Probably correct * Unsupported * Misleading * Incorrect * Unable to verify

Use when accuracy matters more than speed.

/triplecheck [CONTENT / CLAIM / CALCULATION / CODE]

Instruction:

Check this three separate ways.
Do not assume the first answer is correct.
Report any contradictions.

Full audit of a system, document, website, proposal, configuration, business, or codebase.

/audit [TARGET]

Optional scope:

/audit [TARGET]

AUDIT:

* Accuracy
* Completeness
* Security
* Legal/compliance
* Performance
* Usability
* Commercial viability
* Failure modes

  

Actively try to find weaknesses instead of validating the existing design.

/redteam [SYSTEM / PLAN / CLAIM / PRODUCT]

Ask:

Assume the design is wrong.
Attempt to break it.
Find:
- Critical failures
- Security holes
- False assumptions
- Edge cases
- Abuse cases
- Commercial weaknesses
- Regulatory problems
- Scalability limits

Force the AI to argue against your current idea.

/devilsadvocate [IDEA]

Excellent for:

* Inventions * Business plans * Investment decisions * Pricing * Product strategy * Architecture

Side-by-side comparison.

/compare [OPTION A] vs [OPTION B]

Better:

/compare PostgreSQL vs MareeDB

Score each 0-10:

* Performance
* Reliability
* Security
* Scalability
* Ease of deployment
* Ecosystem
* Compatibility
* Cost
* Enterprise suitability

  

Rank options objectively.

/rank [OPTIONS]

Example:

/rank
PostgreSQL
MySQL
MariaDB
SQL Server
MareeDB

FOR:
Embedded enterprise database use

SCORE:
0-10

GIVE:
Winner + reasons 

Request the strongest practical solution rather than a generic answer.

/ultimate [OBJECTIVE]

Better wording:

Find the absolute best technically and commercially realistic solution.

Do not optimise for popularity.
Optimise for actual outcome. 

Generate zero-assumption instructions.

/idiotguide [TASK]

Expected format:

* What you need * Before you start * Step 1 * Exact button/menu * Exact value to enter * What you should see * Step 2 * Verification * Troubleshooting * Rollback

Simpler procedural version.

/stepbystep [TASK]

Make a concept easier to understand visually.

/visualguide [SUBJECT]

Useful output styles:

ASCII diagram
flowchart
decision tree
table
before/after
architecture diagram
timeline

Explain something from first principles.

/eli5 [SUBJECT]

This does not mean inaccurate or childish.

It means:

* No assumed technical knowledge * Define jargon * Build concepts progressively

Give the engineering-level explanation.

/technical [SUBJECT]

Condense a complex subject for an owner/director/executive.

/executive [SUBJECT]

Focus:

* What matters * Why * Cost * Risk * Decision * Action

Force a concise answer.

/short [QUESTION]

Force the AI to make a decision rather than giving endless alternatives.

/oneanswer [QUESTION]

Example:

/oneanswer
Which database port should MareeDB use?

Return the strongest five options.

/top5 [SUBJECT]

Score something using a defined scale.

/score [ITEM] 0-10

Better:

/score [ITEM]

Security: /10
Performance: /10
Reliability: /10
Commercial viability: /10
Overall: /10 

Force a clear final determination.

/verdict [QUESTION]

Output should finish with:

VERDICT:
YES / NO / CONDITIONAL

REASON:
... 

/seo https://example.com

Analyse:

* Technical SEO * On-page SEO * Titles * Meta descriptions * Headings * Schema * Internal linking * Content * Search intent * Core Web Vitals * Crawlability * Indexability * Sitemap * robots.txt * Canonicals * Images * Backlinks * Local SEO

/seoaudit https://example.com

Use for a deeper audit than /seo.

/conversion https://example.com

Analyse website visitor → customer conversion.

Conversion Rate Optimisation.

/cro https://example.com

Create or analyse a landing page.

/landingpage [PRODUCT]

Master website improvement prompt.

/websiteultimate https://example.com

Analyse and improve:

* SEO
* GEO / AI search discoverability
* Speed
* Accessibility
* Security
* Trust
* Copy
* Design
* Mobile
* Conversion
* Analytics
* Structured data
* Technical quality

  

/sitemap [WEBSITE OR ZIP]

Use to create/review sitemap.xml.

/robots https://example.com

Review/create robots.txt.

/schema [PAGE / BUSINESS]

Generate appropriate JSON-LD structured data.

/meta [PAGE CONTENT]

Create:

* SEO title * Meta description * Open Graph tags * X/Twitter tags

/businessanalysis [COMPANY / IDEA]

/businessplan [BUSINESS]

/marketsize [PRODUCT] [COUNTRY]

Calculate where possible:

* TAM * SAM * SOM * Number of potential buyers * Price assumptions * Potential ARR

/revenue [BUSINESS]

Request:

* Worst case * Expected case * Best case * Monthly * 6 months * 1 year * 2 years * 3 years * 5 years * 10 years

/pricing [PRODUCT]

Analyse:

* Cost * Competitors * Value * Willingness to pay * Gross margin * Tiers * Entry pricing * Enterprise pricing

/uniteconomics [BUSINESS NUMBERS]

Calculate:

* CAC * LTV * LTV:CAC * ARPU * Gross margin * Contribution margin * Churn * Payback period * Break-even

/breakeven

PRICE:
$

VARIABLE COST:
$

FIXED COST:
$ 

/competitors [PRODUCT] [MARKET]

/swot [BUSINESS / PRODUCT]

Analyse sustainable competitive advantage.

/moat [BUSINESS / TECHNOLOGY]

Go-To-Market strategy.

/gtm [PRODUCT]

/mvp [PRODUCT IDEA]

Determine the minimum genuinely useful product.

/enterprise [PRODUCT]

Analyse what is needed before large enterprises can adopt it.

Especially useful for inventions/patents.

/commercialise [INVENTION]

Include:

* IP * Prototype * Validation * Manufacturing * Certification * Funding * Licensing * Distribution * Market entry * Scale

/codeaudit [CODE / REPOSITORY / FILE]

Review:

* Bugs * Security * Architecture * Performance * Maintainability * Error handling * Edge cases

/securityaudit [CODE / SYSTEM]

/bughunt [CODE / ERROR]

Instruction:

Do not merely explain the error.
Trace the likely root cause.
Give the exact fix.
Then verify the fix does not introduce another fault.

/fix [ERROR / CODE]

/harden [SERVER / APP / CONFIG]

Look for:

* Authentication * Authorisation * Network exposure * Secrets * Encryption * Logging * Rate limits * Input validation * Updates * Backups * Recovery

/architecture [SYSTEM]

Provide:

* Components * Data flows * Interfaces * Dependencies * Security boundaries * Failure modes

/scale [SYSTEM]

Analyse what breaks at:

100 users
1,000 users
10,000 users
100,000 users
1 million users
10 million users

/benchmark [SYSTEM A] vs [SYSTEM B]

Require identical test assumptions.

/productionready [APPLICATION]

Look for everything missing between:

"It works"

and:

"It can safely run in production."

Useful for AI-generated software.

/zero-stubs [CODEBASE]

Find:

* TODOs * Fake implementations * Placeholder returns * Hard-coded mocks * Unsupported claims * Empty handlers * Functions that silently do nothing

/api [REQUIREMENT]

Design:

* Endpoints * Methods * Authentication * Request schema * Response schema * Errors * Rate limiting * Versioning

/database [REQUIREMENT]

Design:

* Tables * Fields * Types * Keys * Relationships * Indexes * Constraints

/migration [FROM] -> [TO]

/linux [TASK]

/windows [TASK]

/cpanel [TASK]

/trmm [TASK]

For TacticalRMM.

/wazuh [TASK]

/n8n [WORKFLOW]

/network [PROBLEM]

Troubleshoot systematically.

/diagnose [PROBLEM]

Required order:

1. Symptoms
2. Most likely causes
3. Tests
4. Interpret each possible result
5. Fix
6. Verification
7. Rollback

Useful when the explanation is unnecessary.

/commandsonly [TASK]

Useful before altering production systems.

/safechange [TASK]

Require:

* Backup * Restore point * Current-state capture * Change * Verification * Rollback command

/threatmodel [SYSTEM]

Identify:

* Assets * Attackers * Entry points * Trust boundaries * Threats * Controls

/vulncheck [SOFTWARE / VERSION]

/cve [PRODUCT VERSION]

/attacksurface [SYSTEM]

/privacy [SYSTEM / POLICY / WEBSITE]

Analyse:

* Information collected * Purpose * Consent * Storage * Location * Third parties * Retention * Deletion * Access * Security

/rewrite [TEXT]

/professional [TEXT]

/legalwording [TEXT]

Note: Improves legal-style drafting but is not a substitute for jurisdiction-specific legal advice.

/email

TO:
[person]

PURPOSE:
[reason]

TONE:
professional

DETAILS:
... 

/docuwiki [CONTENT]

Return DokuWiki-compatible markup.

/markdown [CONTENT]

/table [DATA / SUBJECT]

/checklist [TASK]

/template [DOCUMENT TYPE]

/rootcause [PROBLEM]

/5why [PROBLEM]

Strip assumptions and rebuild the problem logically.

/firstprinciples [PROBLEM]

/assumptions [PLAN / ANSWER]

List every important assumption being made.

/blindspots [PLAN / PRODUCT / DECISION]

/whatamimissing [PLAN]

/failuremodes [SYSTEM]

/edgecases [SYSTEM / PROCESS]

/risks [PROJECT]

Return:

/decision [CHOICE]

Useful format:

OPTIONS:
A
B
C

OBJECTIVE:
...

WEIGHT:
Cost 20%
Performance 30%
Risk 30%
Ease 20% 

Weak:

Tell me about Australian privacy law.

Better:

Research current Australian privacy law.

Use primary sources first:

* legislation.gov.au
* OAIC
* Australian Government
* regulators

Use secondary sources only for explanation. 

For changing subjects:

Use information current as at today's date.
Do not rely on outdated regulations, prices, versions or product information.

Separate the answer into:

CONFIRMED FACT
REASONABLE INFERENCE
ASSUMPTION
UNKNOWN 

Search for evidence that contradicts the initial conclusion.
Do not stop after finding supporting evidence.

Source priority:

1. Legislation / regulator / official authority
2. Vendor documentation
3. Peer-reviewed research
4. Major reputable publications
5. Industry sources
6. Forums/community sources

Do not use low-quality SEO articles as primary evidence. 

The basic high-quality prompt formula:

ROLE:
Act as [expert role].

OBJECTIVE:
[exact result wanted]

CONTEXT:
[important background]

INPUT:
[data / content / URL / numbers]

CONSTRAINTS:
[things that must or must not happen]

RESEARCH:
[current information / sources / jurisdiction]

OUTPUT:
[exact output format]

QUALITY CONTROL:
Verify calculations, claims, assumptions and contradictions before answering. 

Use this when a task matters.

Act as a senior multidisciplinary expert in every field relevant to this task.

OBJECTIVE
Produce the strongest factually defensible and practically usable solution.

RULES

1. Do not invent facts.
2. Do not silently assume missing facts where they materially change the answer.
3. Use current information where the subject can change.
4. Prefer authoritative primary sources.
5. Cross-check important claims.
6. Distinguish confirmed facts from estimates and assumptions.
7. Check calculations independently.
8. Look for contradictions.
9. Look for edge cases and failure modes.
10. Identify anything I have overlooked.
11. Challenge my assumptions where necessary.
12. Do not agree merely because I proposed the idea.
13. Prefer technically correct answers over popular answers.
14. Prefer practical solutions over theoretical perfection.
15. Explain specialist terminology.
16. Give exact steps where implementation is required.
17. Include verification steps.
18. Include rollback steps where a change could cause damage.
19. State uncertainty explicitly.
20. Finish with a clear conclusion or recommendation.

OUTPUT
Use headings, tables, diagrams and short sections where they improve clarity. 

Act as the principal software architect, senior developer, security engineer,
QA engineer and production operations engineer.

Evaluate this as software intended for real production use.

Check:

ARCHITECTURE

* Overall architecture
* Component boundaries
* Dependencies
* Scalability
* Maintainability

CODE

* Bugs
* Race conditions
* Memory problems
* Resource leaks
* Error handling
* Type problems
* Incorrect assumptions

SECURITY

* Authentication
* Authorisation
* Injection
* XSS
* CSRF
* SSRF
* RCE
* Path traversal
* Secrets
* Cryptography
* Session security
* API abuse
* Rate limiting

DATABASE

* Schema
* Constraints
* Transactions
* Concurrency
* Indexes
* Query efficiency
* Backups
* Recovery

PRODUCTION

* Logging
* Monitoring
* Alerting
* Configuration
* Updates
* Deployment
* Rollback
* Disaster recovery

QUALITY

* Unit tests
* Integration tests
* Regression tests
* Edge cases

ZERO-STUB CHECK
Find:

* TODO
* FIXME
* placeholder
* mock
* stub
* fake success
* hard-coded test values
* unimplemented branches

Do not simply describe problems.

For every important problem give:

1. Severity
2. Location
3. Cause
4. Consequence
5. Exact correction
6. How to test the correction

   

Perform a complete professional audit of:

[URL]

Analyse it as:

* Technical architect
* SEO specialist
* Conversion specialist
* UX specialist
* Accessibility specialist
* Security specialist
* Marketing strategist
* Customer
* Search engine crawler

Evaluate:

TECHNICAL
SEO
GEO / AI SEARCH
PERFORMANCE
MOBILE
ACCESSIBILITY
SECURITY
CONTENT
COPY
TRUST
BRANDING
NAVIGATION
USER EXPERIENCE
ANALYTICS
CONVERSION
CALLS TO ACTION
SCHEMA
INTERNAL LINKS
EXTERNAL LINKS
INDEXABILITY
ROBOTS
SITEMAP
COMPETITORS

For every problem give:

SEVERITY:
CRITICAL / HIGH / MEDIUM / LOW

CURRENT:
What exists now.

PROBLEM:
Why it matters.

FIX:
Exactly what should change.

PRIORITY:
The order it should be implemented. 

Act as:

* CEO
* CFO
* COO
* CTO
* CMO
* Strategy consultant
* Commercialisation specialist
* Investor
* Competitor

Analyse:

[BUSINESS / PRODUCT]

Determine:

1. Problem being solved
2. Target customer
3. Market size
4. Demand
5. Competition
6. Differentiation
7. Defensibility
8. Pricing
9. Cost structure
10. Unit economics
11. Gross margin
12. Customer acquisition
13. Retention
14. Distribution
15. Sales model
16. Operational requirements
17. Technology requirements
18. Legal/regulatory issues
19. Major risks
20. Scaling limitations
21. Capital requirements
22. Worst-case outcome
23. Expected outcome
24. Best-case outcome
25. Commercial potential

Then answer:

WHAT WOULD MAKE THIS FAIL?

WHAT WOULD MAKE THIS DOMINATE?

WHAT SHOULD BE DONE NEXT? 

Analyse this invention:

[INVENTION]

Act as:

* Inventor
* Mechanical/electrical/software engineer as applicable
* Manufacturing engineer
* Patent strategist
* Product designer
* Safety engineer
* Regulator
* Investor
* Customer
* Competitor

Analyse:

NOVELTY
TECHNICAL FEASIBILITY
PRIOR ART RISK
PATENTABILITY INDICATORS
DESIGN-AROUND RISK
MANUFACTURABILITY
MATERIALS
COST
SAFETY
REGULATION
CERTIFICATION
MAINTENANCE
USER ACCEPTANCE
COMMERCIAL VIABILITY
LICENSING
COMPETITION
SCALABILITY

Attempt to invalidate the invention before recommending it. 

A strong image-generation prompt describes:

SUBJECT:
What must appear.

COMPOSITION:
Camera position and arrangement.

ENVIRONMENT:
Where the subject is.

LIGHT:
Lighting conditions.

MATERIAL:
Surface/material properties.

STYLE:
Photorealistic / technical illustration / etc.

CAMERA:
Lens, angle, distance where relevant.

DETAIL:
Fine detail requirements.

RESTRICTIONS:
What must NOT appear. 

Example:

Photorealistic exploded technical view of a modern mechanical keyboard.

Show:

* keycaps
* switches
* switch plate
* PCB
* stabilisers
* foam
* controller
* USB interface
* lower chassis
* feet
* fasteners

Arrange every component vertically in correct assembly order.

Three-quarter isometric engineering perspective.
Neutral studio background.
Realistic materials.
Extremely sharp detail.
No missing components.
No fantasy components. 

AI often performs better when told what not to do.

Example:

DO NOT:
- invent facts
- invent sources
- assume unsupported details
- change existing headings
- remove functionality
- simplify away important technical details
- use placeholders
- create fake statistics

Useful phrase:

Before answering, determine what categories would need to be covered for this
answer to genuinely be complete.

Then ensure every category has been addressed. 

Before finalising:

1. Try to prove your answer wrong.
2. Check every calculation.
3. Identify unsupported claims.
4. Identify assumptions.
5. Look for missing edge cases.
6. Correct any problems found.
7. Only then provide the final answer.

   

AI frequently gives too many alternatives.

Use:

Do not finish with "it depends".

Account for the stated requirements and choose the best option.

Give:

WINNER:
...

SCORE:
x/10

WHY:
...

RUNNER-UP:
...

WHY IT LOST:
... 

Use:

If information is unavailable, say "UNKNOWN".

Do not fill missing information with plausible-looking values. 

List any assumption that materially affects the answer.

For each assumption state:

ASSUMPTION:
...

WHY REQUIRED:
...

WHAT CHANGES IF WRONG:
... 

Use:

Show:
- Formula
- Inputs
- Calculation
- Result

Then independently recalculate the result using a second method. 

Example:

Revenue = Customers × Monthly Price × 12

Customers = 500
Monthly Price = $199

500 × $199 × 12
= $1,194,000 ARR 

Use three or more scenarios.

Never confuse maximum theoretical market size with a realistic forecast.

Use when choosing technology/products.

Example:

Then calculate weighted totals.

Ask:

For each major conclusion give:

CONFIDENCE:
HIGH / MEDIUM / LOW

and explain why. 

Extremely useful for preventing confirmation bias.

State your conclusion.

Then state what evidence would cause you to change that conclusion. 

ARGUMENT FOR:
...

ARGUMENT AGAINST:
...

STRONGEST EVIDENCE FOR:
...

STRONGEST EVIDENCE AGAINST:
...

FINAL ASSESSMENT:
... 

Instead of restarting a long prompt:

Keep everything else unchanged.

Change only:
[requirement] 

or:

Use the previous result as version 1.

Create version 2 with:
[list of changes]

Do not remove anything that is still applicable. 

Especially useful for reports.

Do not change, rename, combine, delete or reorder existing headings.
Only improve the content inside them.

Add any of these to normal prompts:

Do not assume I am correct.

Challenge the premise.

Use first principles.

Look for what I have missed.

Search for contradictory evidence.

Separate facts from assumptions.

Do not invent missing information.

Use primary sources where possible.

Verify anything that may have changed recently.

Quantify the answer wherever possible.

Give exact numbers rather than vague descriptions where defensible.

Give the strongest counterargument.

Identify edge cases.

Identify failure modes.

Tell me what would cause this solution to fail.

Give implementation steps, not merely recommendations.

Give verification steps after every major change.

Include rollback instructions.

Do not optimise for agreeing with me.
Optimise for being correct.

Shortcuts can be stacked conceptually.

Example:

/deepresearch /compare /rank

Compare the top Australian allied-health practice-management platforms.

Current information only.

Rank them for:

* OT
* NDIS
* Medicare
* DVA
* multidisciplinary use

  

Another:

/audit /redteam /securityaudit

Audit this SaaS application.

Assume an attacker is actively looking for:

* authentication bypass
* tenant isolation failure
* privilege escalation
* data leakage

  

Another:

/showcase /seo /conversion

[https://example.com](https://example.com)

Analyse both discoverability and visitor-to-customer conversion. 

For everyday use:

/showcase
/metaads
/explodedview

/deepresearch
/factcheck
/triplecheck

/audit
/redteam
/compare
/rank
/score
/verdict

/ultimate
/oneanswer
/top5

/idiotguide
/stepbystep
/visualguide
/eli5

/seo
/ conversion
/sitemap
/schema

/businessanalysis
/marketsize
/revenue
/pricing
/uniteconomics
/competitors
/gtm

/codeaudit
/securityaudit
/bughunt
/fix
/harden
/architecture
/scale
/productionready
/zero-stubs

/linux
/windows
/cpanel
/trmm
/wazuh
/n8n
/network
/diagnose
/safechange

/rewrite
/professional
/docuwiki
/markdown
/table
/checklist

/rootcause
/firstprinciples
/assumptions
/blindspots
/whatamimissing
/failuremodes
/edgecases
/risks
/decision 

Add this to almost any serious prompt:

Do not assume my premise is correct; verify current facts, challenge assumptions,
find missing issues and edge cases, use authoritative sources, distinguish fact
from inference, check all calculations, and give the strongest practical
recommendation with exact implementation and verification steps.

Research this using current authoritative information.

Use primary sources first.
Cross-check material claims using independent sources.
Check publication dates and whether information remains current.
Search for evidence both supporting and contradicting the likely conclusion.
Do not convert estimates into facts.
Clearly label uncertainty. 

Treat this as a production-critical system.

Check architecture, security, reliability, performance, compatibility,
maintainability, scalability, logging, monitoring, backups, recovery,
failure modes and edge cases.

Find the root cause rather than treating symptoms.

Give exact implementation, testing, verification and rollback instructions. 

Evaluate this commercially, not merely technically.

Quantify market size, customer demand, pricing, margins, acquisition cost,
lifetime value, competition, defensibility, capital requirements,
operational constraints, risks and realistic scalability.

Separate theoretical maximum potential from achievable forecasts. 

Accuracy is more important than producing an impressive answer.

Do not invent:

* Facts
* Statistics
* Features
* Benchmarks
* Customers
* Partnerships
* Certifications
* Legal requirements
* Sources

If something cannot be verified, state that clearly.

If my premise is wrong, say so.

If the answer is uncertain, quantify or explain the uncertainty.

If there are credible arguments against the conclusion, include them.

Do not convert speculation into fact.