-
Notifications
You must be signed in to change notification settings - Fork 0
Examples
Every example on this page was generated by Wild_Root_Prompt itself, not written by hand. Same conditions throughout: a single 8B model (llama3:latest) running locally through Ollama, --offline (no web enrichment), no session memory, default technique set. Nothing was edited afterwards.
If you want to reproduce any of them, the exact command is printed above each one.
New here? Quick Start gets you running in two minutes. Want the theory instead? The 173 techniques.
The kind of thing people actually type at 11pm.
make me a thing for my website that works idk something with the database its slow fix it
No object, no stack, no success criteria, no deliverable. Most tools would return a generic essay about database optimization.
python3 prompt_expert_enhance.py generate \
"make me a thing for my website that works idk something with the database its slow fix it" \
--model llama3:latest --mode quick --offlineBefore any technique is applied, a local model rewrites the raw text into a real specification:
Design and implement a scalable database-driven solution to optimize the performance of your website, ensuring seamless integration with existing database infrastructure. To achieve this, follow these concrete steps:
- Conduct a thorough analysis of the current database schema and identify bottlenecks causing slow performance.
- Develop a comprehensive plan to refactor the database architecture, incorporating indexing strategies and query optimization techniques as necessary.
- Implement a caching mechanism to reduce the load on the database and improve overall system responsiveness.
- Integrate the optimized database solution with your website's existing infrastructure, ensuring a seamless user experience.
Deliverable: A fully functional, high-performance database-driven website that meets the requirements outlined above, with clear documentation of the optimization strategies employed.
Note what appeared out of nothing: a deliverable, an ordered method, and an explicit diagnosis-before-fix sequence. "its slow fix it" became "identify bottlenecks, then refactor".
Techniques are then injected on top:
Design a high-performance database-driven feature for your website by following these step-by-step instructions:
- Conduct a thorough analysis of the current database schema, identifying potential bottlenecks contributing to slow performance, then explain each bottleneck in detail.
- Develop a comprehensive plan to optimize database queries, incorporating indexing strategies, caching mechanisms, query optimization techniques, and explain how each technique will improve system speed.
- Implement a scalable data processing pipeline that efficiently handles large datasets using parallel processing and distributed computing methods where feasible, providing three distinct examples of real-world applications.
- Integrate the optimized database feature with your website's existing architecture, ensuring seamless integration and minimal disruption to existing functionality, as if you have no word limit.
Note: This implementation should significantly improve overall system speed without compromising data integrity or security. Provide a detailed outline of the proposed solution before elaborating on each point.
The bolded fragments are techniques doing their work — recursive deepening, example-driven expansion, no word limit, outline-then-expand. 17 words in, a structured brief out.
The user knows what hurts but not what to ask for.
how do i make my python script faster it takes forever
python3 prompt_expert_enhance.py generate \
"how do i make my python script faster it takes forever" \
--model llama3:latest --mode quick --offlineWrite a Python script that optimizes execution speed and reduces processing time to achieve a significant performance boost, ensuring that the script completes within a reasonable timeframe. To accomplish this, follow these concrete steps:
- Identify and refactor slow-performing sections of the code using profiling tools and techniques.
- Implement efficient data structures and algorithms to minimize memory usage and computational complexity.
- Utilize Python's built-in just-in-time (JIT) compiler and other optimization features to leverage hardware-specific instructions and parallel processing capabilities.
Deliverable: A well-documented, optimized Python script that meets the performance requirements, accompanied by a detailed report outlining the improvements made and their corresponding impact on execution speed.
Write a step-by-step guide on how to optimize a Python script's execution time for a significant speedup, reducing processing duration from "forever" to a reasonable timeframe. Think step-by-step before answering.
To achieve this, consider three approaches:
- Identify and refactor performance-critical sections of the code using built-in profiling tools like cProfile or third-party libraries such as line_profiler, explaining each refactoring step by step.
- Implement efficient data structures and algorithms for handling large datasets, leveraging NumPy and Pandas libraries as needed, and explain each optimization technique thoroughly.
- Optimize memory allocation and garbage collection by minimizing object creation, reusing existing objects, employing techniques like memoization or caching, and provide detailed explanations for each approach.
Then, validate the optimized script's performance improvements through thorough testing and benchmarking […]
Explain each sub-point in detail:
- What are the most critical steps to identify and refactor performance-critical sections?
- How do you leverage NumPy and Pandas libraries to optimize dataset handling?
- What specific techniques can be employed to minimize object creation and reuse existing objects?
As if you have no word limit, please provide concrete examples for each main claim, demonstrating how these optimizations can lead to a significant speedup.
What a novice gained without knowing any of it: the word profiling — the single most important concept for their actual problem — plus cProfile, line_profiler, NumPy, Pandas, memoization, and the idea that you benchmark before and after. The tool didn't just reformat the question; it supplied the vocabulary needed to ask it properly.
This is the strongest argument for the pre-processor: it closes the gap between what a beginner can articulate and what an expert would have asked.
Stage 1 suggested "Python's built-in just-in-time (JIT) compiler", which is misleading — CPython has no general-purpose JIT you simply switch on. Wild_Root_Prompt structures reasoning; it does not fact-check. The output is a better question, not a verified answer. For claim-level rigor, add /sources, /precision or /confiance — see Slash Metacommands — or read Limitations and Roadmap.
Same tool, three inline modifiers, pre-processor deliberately off so you can see the techniques in isolation.
python3 prompt_expert_enhance.py generate \
"/expert /tableau /sources compare REST and GraphQL for a mobile app backend" \
--model llama3:latest --mode quick --offline --no-preprocessCompare RESTful API and GraphQL architecture for a mobile app backend, considering the following three approaches:
- Step-by-step analysis: Evaluate the strengths and weaknesses of each approach, focusing on scalability, data complexity, and development ease.
- Tree of Thought (ToT): Explore multiple branches of reasoning, evaluating each branch's validity, and backtrack when necessary.
- Forced reframing: Rephrase this question as follows: "Design a scalable mobile app backend that leverages either REST or GraphQL; justify your choice."
Do not give a short answer. Develop each point thoroughly.
Explain how RESTful APIs handle requests and responses, including caching mechanisms and query parameter handling. Then, describe how GraphQL addresses these limitations with its schema-based approach and subscription mechanism.
As if you have no word limit, provide detailed examples of real-world applications that successfully implemented both architectures.
Counter-argument inclusion: Present strong arguments for and against each approach, then synthesize the findings.
Recursive deepening: After discussing each approach's advantages and disadvantages, explain in detail why one might be more suitable than the other for a specific use case.
Example-driven expansion: Provide three distinct, real-world examples for each main claim […] Example 3: [briefly describe a failed attempt]
Notice "Example 3: a failed attempt" — the technique set deliberately forces a negative case. That is the difference between a comparison that flatters both options and one that is actually useful.
/tableau requested table output, and the result is prose. That's correct behavior, and worth understanding: in Quick mode the output is the enhanced prompt, not the final answer. Formatting metacommands are carried inside that prompt for the downstream model to obey. Paste this into any LLM and you get the table.
Want the table immediately? Use --mode full, which generates the deliverable itself.
Quick mode gives a prompt. Full mode gives the deliverable. --draft renders only sections 1–2, which is the cheap way to check direction before committing to a complete run.
python3 prompt_expert_enhance.py generate \
"build a CLI tool that renames photo files based on their EXIF date" \
--model llama3:latest --mode full --draft --offline§ 1. TITLE & EXECUTIVE SUMMARY
Command-Line Interface Tool for Renaming Digital Photograph Files Based on EXIF Metadata
The objective of this project is to design and develop a command-line interface (CLI) tool that automates the process of renaming digital photograph files based on their embedded Exchangeable Image File (EXIF) metadata. Specifically, the tool should utilize the date information stored in each file's EXIF data to generate unique, descriptive filenames for each image.
§ 2. FINAL OBJECTIVE & SUCCESS DEFINITION
Success will be achieved when the CLI tool can be executed from a terminal or command prompt, allowing users to specify a directory or set of directories containing photo files to be processed. The tool should provide features such as file selection, date-based renaming, optional metadata filtering, and output format control. A working CLI tool with clear documentation on its usage and features constitutes success.
Drop --draft and the same command produces all twelve sections — execution context, ambiguity zones, step decomposition, control loops, guardrails, error handling, reproducibility checklist. That document is designed to be handed to an agent and executed, which is why ambiguity zones get a section of their own.
git clone https://github.com/TFD-42/Wild_Root_Prompt.git
cd Wild_Root_Prompt && ./install.sh
ollama pull llama3Then run any command above. Expect wording to differ — LLMs are stochastic, and the default temperature is 0.3, not 0.0. Set --temperature 0.0 if you need reproducible output. The structure is what stays stable, and the structure is the point.
More runnable commands live in examples/ in the repository.
| Observation | Where it shows |
|---|---|
| Vague input becomes a specification with an explicit deliverable | Examples 1 & 2, stage 1 |
| Domain vocabulary a beginner lacked is supplied automatically | Example 2 (cProfile, profiling, benchmarking) |
| Diagnosis is forced before solution | Example 1 ("identify bottlenecks" before "refactor") |
| Comparisons are forced to include failure cases | Example 3 ("a failed attempt") |
| Output structure is stable even when wording isn't | Example 4 |
| It structures reasoning — it does not verify facts | Example 2's JIT caveat |
- Quick Start — run your own in two minutes
-
Slash Metacommands — reshape output with
/expert,/tableau,/sources - Templates and Bundles — pre-picked technique sets per task type
- Use Cases — what people build with it
- Limitations and Roadmap — what it does not do
Start
Reference
Understand
Help