PromptisePromptise
Why PromptiseUse casesRoadmapDocs
GitHubGet started
Promptise - AI Framework LogoPromptise

The foundation layer for agentic intelligence. Build, secure and operate autonomous AI systems with Promptise Foundry.

pip install promptise

[01] Foundry

  • MCPcast
  • The Promptise Agent
  • Reasoning Engine
  • MCP
  • Agent Runtime
  • Prompt Engineering
  • Execution Engine
  • Agent Identity

[02] Resources

  • Documentation
  • GitHub
  • Guides
  • Learning Paths
  • Questions

[03] Company

  • About
  • Terms of Service
  • Privacy Policy
  • Cookie Policy
  • Subprocessors

© 2026 Promptise by Manser Ventures. All rights reserved.

Open source · Python

← Learning paths> Prompt Engineering· featured
Advanced path

Advance Prompt Engineering

Start the pathAll paths

This path teaches you to design prompts that do more than generate answers. They reason, verify, adapt and collaborate. You’ll learn how to build workflows that reduce errors, create consistency, and scale across complex tasks. Each guide combines theory with practice, so you’ll not only understand the techniques but also test them in small labs that make the difference visible. By the end, you’ll know how to turn a single model into a reliable system: one that can explain its steps, double-check its own work, and even coordinate multiple reasoning strategies before deciding on the best answer.

23
Lessons
4 h
Reading time
Advanced
Level
Free
Cost

The lessons

23 lessons

Read the lessons in order; they are arranged so each one prepares the next. Every lesson is a guide, so you can also open any of them on its own.

  1. [01]LLM Hallucinations: Why They Happen and Quick ChecksWhy LLMs hallucinate and how to catch it: spot risky questions, allow "I don't know", require quotes and check them in code. Real fake-citation example.Beginner · 7 minOpen →
  2. [02]LLM Tone and Style: Write a Style Guide PromptControl LLM tone, voice and length with a style guide in the system prompt: rules, banned words, one example and code checks. Real before-and-after output.Beginner · 6 minOpen →
  3. [03]RAG for Beginners: Build a Tiny RAG Pipeline in PythonBuild a tiny RAG pipeline in Python: chunk Markdown files, embed and retrieve passages, cite sources and admit when the docs don't cover it. Real output.Beginner · 7 minOpen →
  4. [04]LLM Tool Call Planning: Validate Plans Before ExecutingHave the LLM plan multi-step API calls as JSON, validate tools, arguments and guards in code, then execute safely. Python code and a real plan that failed.Advanced · 8 minOpen →
  5. [05]Self-Consistency and Least-to-Most Prompting: When They HelpSelf-consistency and least-to-most prompting explained: how voting and decomposition work, real examples, and when reasoning models make them unnecessary.Advanced · 9 minOpen →
  6. [06]Self-Ask Prompting, Auto-CoT and Decomposition PromptsSelf-Ask prompting and Auto-CoT explained: split multi-hop questions into follow-ups, plug in search, and know when reasoning models need it. Real output.Advanced · 8 minOpen →
  7. [07]Chain-of-Verification and SelfCheckGPT: Catch HallucinationsChain-of-Verification (CoVe) and SelfCheckGPT explained: draft, verify with independent questions, flag claims that samples disagree on. Real pitfalls.Advanced · 9 minOpen →
  8. [08]LLM Self-Correction: Self-Refine, Reflexion and CRITICLLM self-correction without fine-tuning: how Self-Refine, Reflexion and CRITIC work, why external feedback matters, and a real self-review vs test example.Advanced · 7 minOpen →
  9. [09]Tree of Thoughts Prompting: How ToT Works and When to Use ItTree of Thoughts (ToT) and Graph of Thoughts explained: propose, score and prune reasoning steps, a runnable Game of 24 search, and cheaper modern options.Advanced · 9 minOpen →
  10. [10]Skeleton-of-Thought: Outline First, Expand in ParallelSkeleton-of-Thought prompting: write the outline in one call, expand each point in parallel under a word budget. Runnable Python, real output, and limits.Advanced · 7 minOpen →
  11. [11]Long-Form LLM Writing: Control Length, Structure, StyleGenerate long-form content with an LLM: outlines with word budgets, one section per call, style rules you can check in code. Real 1,200-word example.Intermediate · 8 minOpen →
  12. [12]Long-Context Prompting: Placement, Structure and RAGLong-context prompting tactics: where to put documents and the question, how to tag sources, quote-then-answer, and when to retrieve instead of stuffing.Intermediate · 8 minOpen →
  13. [13]Prompt Compression: LLMLingua and Lost in the MiddlePrompt compression techniques compared: selection, LLMLingua, summaries. Fix lost in the middle with reordering. Real example: 15,900 tokens cut to 1,400.Advanced · 9 minOpen →
  14. [14]LLM Routing: When to Use a Small vs Large ModelLLM routing explained: rules, LLM routers, learned routers and cascades to send each request to the cheapest model that works. A real router misroute.Intermediate · 7 minOpen →
  15. [15]Prompt Ensembles and LLM Judges: Generate, Rank, RespondPrompt ensembles and rank-then-respond: generate candidates with prompt variants, rank them with an LLM judge, and correct for position bias. Real example.Advanced · 8 minOpen →
  16. [16]Active Prompting: Pick the Few-Shot Examples That MatterActive prompting explained: sample answers, measure disagreement, and annotate only the most uncertain inputs as few-shot examples. Runnable code, output.Advanced · 8 minOpen →
  17. [17]Directional Stimulus Prompting: How Hints Improve OutputDirectional stimulus prompting adds a per-input hint, such as keywords, so the AI's response keeps what matters. How it works, plus a prompt-only build.Advanced · 7 minOpen →
  18. [18]Automatic Prompt Optimization: APE, ProTeGi and AMPOAutomatic prompt optimization explained: APE, ProTeGi, OPRO and multi-branch prompts, with one real optimization round on a ticket classifier in Python.Advanced · 9 minOpen →
  19. [19]ReAct Agent From Scratch in Python: The Reason-Act LoopBuild a ReAct agent from scratch in Python: the Thought, Action, Observation loop, a 60-line controller with a real trace, and how it maps to tool calling.Intermediate · 8 minOpen →
  20. [20]Program-of-Thought in Python: Run Model Code SafelyCompute answers with model-written code in Python: an output contract, a locked-down Docker sandbox, a two-run check, and when to use a code tool instead.Advanced · 8 minOpen →
  21. [21]What Are PAL and Program-of-Thought Prompting?PAL and Program-of-Thought prompting explained: the model writes code, an interpreter computes the answer. How they differ, when to use them, real example.Intermediate · 7 minOpen →
  22. [22]LLM Agent Orchestration Patterns: Supervisor, HandoffLLM agent orchestration patterns: single agent, chaining, routing, supervisor-workers and handoffs. When each fits and what the controller must enforce.Intermediate · 8 minOpen →
  23. [23]Semantic Entropy: Detect When an LLM Is UnsureSemantic entropy explained: sample answers, group them by meaning, and use the entropy to decide when to answer, retrieve or abstain. Runnable Python code.Advanced · 8 minOpen →
Start lesson 01

Before you start

  • Comfort with beginner-level prompting (roles, clarity, structured outputs).
  • Basic familiarity with JSON or schema-based outputs.
  • No coding required, but some examples reference API-style workflows.

Skills you build

  • Error reduction with verification and self-check prompts
  • Multi-step reasoning design (linear, tree, and graph-based)
  • Style, tone, and density control for long-form outputs
  • Prompt compression and efficiency strategies
  • Adaptive routing between models and prompt types
  • Meta-prompting and ensemble methods
  • Agent orchestration with reasoning and tool use

By the end, you can

  1. 01Design multi-step reasoning prompts that improve accuracy over single-shot instructions
  2. 02Apply verification and self-check strategies to reduce hallucinations
  3. 03Control tone, style, and density in both short and long-form outputs
  4. 04Use structured reasoning patterns (Chain-of-Thought, Tree-of-Thought, Skeleton-of-Thought) effectively
  5. 05Optimize prompts for long context windows and mitigate “lost-in-the-middle” failures
  6. 06Route queries intelligently between different models or prompt structures
  7. 07Build ensemble prompts that generate, compare, and rank multiple candidate answers
  8. 08Apply meta-prompting to enforce consistency, rules, and style across outputs
  9. 09Create adaptive prompts that reflect, deliberate, or critique before finalizing answers
  10. 10Develop early agentic patterns where models reason, act, and verify in loops

Ready when you are.

23 lessons, in order. Each opens with the full list beside it, so you always know where you are and what comes next.

Start the pathThe guide library