TPEE is a Windows app that helps you write better instructions for AI tools like ChatGPT and Claude — so you get the answers you actually wanted, spend less on wasted tokens, and keep every prompt private on your own machine. 100% offline.
Get TPEE — from $49 Try it in the browser
Offline prompt engineering editor for Windows 10 and 11 · one-time USD $49, $99 or $299 · no subscription. The editors you can click on this page are the real interface, running in your browser with sample text — what you type is not sent anywhere. See the plans.
40+ years of experience condensed in TPEE
The app, right in your browser — click the menus
Interactive replica of the tpee.exe top bar. Menus open like the real app; the items are illustrative — the download does the real work.
The 5-step Prompt Enhancing Workflow — tick the square, then click the arrows
Complete the prompt sections as you would in normal prompt editing.
Interactive replica of the “USE PROMPT ENHANCING WORKFLOW”. Tick the square, then walk the steps with the arrows or the numbered circles — the colours change exactly as in the app. The download does the real workflow. Read how it works ↓
Prompt OnBoarding — the toolbar toggle opens the floating checklist
👁 TPEE can see: 0 of 6 working-environment rows ready · 0 of 13 sections written
Next step: READ THE USER'S MANUAL AND COMPLETE ALL LESSONS
1. Before you start
2. Working environment
3. Fill the prompt sections
4. Use the Prompt Enhancing Workflow
5. Finish and copy
Interactive replica of the app's OnBoarding toggle and its floating Prompt OnBoarding checklist — a demo only, to simulate the real application. Press the toggle to show or hide the checklist, exactly as the toolbar button does in the app; tick the rows and the progress, the live summary and the Next-step lines update the same way. In the real app this button switches the window for the current session only — the tick under Preferences is the one that decides whether the window is there at the next start.
The 🗑 Clipboard-Clear all button beside Copy to Clipboard and Preview is the app's third clipboard control. It empties TPEE's own clipboard and the Windows clipboard history as well (the list you open with Win+V), so a prompt you copied into a chat window cannot be pasted back out of the history by anyone at the keyboard afterwards. It flashes green and orange while it works and settles on green once the clipboard is verifiably empty. On this page it is the same animation only — a demo, to simulate the real application; nothing in your browser clipboard is touched.
Interactive demo of the app's 📋 Copy to Clipboard and 👁 Preview buttons — a demo only, to simulate the real application: the buttons work exactly like the app, but the prompt behind them is a fixed, complete example (the GreenHouse-One project) with all 13 editor sections filled in. In the real app they copy and preview YOUR sections.
This is what will be copied to the clipboard:
You are a senior embedded firmware engineer with 15 years of experience shipping low-power sensor products on ESP32 hardware. You specialise in C/C++ for the Arduino framework, non-blocking state machines, and explaining design decisions clearly to mixed-skill teams. 1. Review the current firmware in the Data section and identify every blocking call. 2. Refactor loop() into a non-blocking state machine with named states. 3. Add hysteresis and a minimum run time to the fan and pump outputs. 4. Comment every function with one line stating its contract. 5. Flag anything that could fail after 30 days of unattended operation. We are building GreenHouse-One, a climate controller for a 3 m x 2 m hobby greenhouse. The first prototype worked for a week, then the pump relay stuck ON because loop() blocked for 47 seconds during a Wi-Fi reconnect and the watchdog reset the board mid-cycle. The firmware must run unattended for months. This is version 2 of the firmware and the hardware is already built, so pin assignments cannot change. Hardware Platform: ESP32-S3-DevKitC-1 (8 MB PSRAM, dual-core 240 MHz). Sensors: SHT31 temperature/humidity on I2C 0x44 (SDA GPIO8, SCL GPIO9), DS18B20 soil temperature on GPIO4, capacitive soil moisture on ADC1_CH3. Actuators: fan relay GPIO12, pump relay GPIO13, both active-LOW. Power: 5 V 2 A supply; the pump draws 800 mA. Toolchain: Arduino IDE 2.3 with the arduino-esp32 core 3.x. Target: 24/7 operation with Wi-Fi telemetry every 60 s. Answer in Markdown with exactly four headings: ## Diagnosis, ## Refactored Code, ## Wiring Notes, ## Test Checklist. All code in fenced blocks with the language tag. List every behavioural change as a before/after pair under ## Diagnosis. Two developers maintain this project: an electronics engineer with a strong C background who is new to FreeRTOS, and a final-year student. Both read C fluently; neither has shipped a 24/7 embedded product before. Direct and methodical. Explain WHY each change matters, not just WHAT changed. No marketing language, no hedging. Cite the datasheet section when you make a hardware claim. Attached below: main.ino (current firmware, 340 lines), the SHT31 datasheet section 4.5 (measurement timing), the relay module schematic, and a serial log excerpt showing the 47-second watchdog reset during the Wi-Fi reconnect at 03:12:44. input: The fan relay chatters when the temperature hovers at the setpoint. output: Add 2 C hysteresis — fan ON at setpoint + 2, OFF at setpoint - 1 — plus a 30-second minimum run time, implemented as explicit states in the state machine under ## Refactored Code. Include an ASCII wiring table under ## Wiring Notes: SHT31 SDA -> GPIO8, SCL -> GPIO9 with 4.7k pull-ups; DS18B20 data -> GPIO4 with a 4.7k pull-up; soil moisture signal -> GPIO3 (ADC1_CH3); fan relay IN -> GPIO12; pump relay IN -> GPIO13; common ground rail mandatory. None. This project is developed fully offline and TPEE never connects to any MCP server. All reference material the model needs is attached in the Data section. If the work is split across agents: Agent 1 reviews sensor timing and I2C error handling, Agent 2 refactors the Wi-Fi reconnect path, Agent 3 writes the hardware test checklist. Merge their findings into one consistent answer before replying.
TPEE keeps six paths on screen so you always know where your project lives: the Working Directory, the two Prefix History folders (chats-and-actions and session-start), your Prompts folder, your TPEE Settings folder and your PRDs folder. That is a tall block, so one button folds it away when you need the vertical space back. This is the button and the six rows, exactly as the app draws them.
Interactive replica of the Show/Hide location toggle and the six Path rows — a demo only, to simulate the real application. Press the button: when the panel is shown it reads Hide location of… and the six rows are visible; press it again and it reads Show location of… with the rows collapsed. In the app the same switch is also a tick box on the Preferences menu, and it is remembered between sessions.
What is it like to edit a prompt in TPEE? The editor is shown here as an interactive replica of the real application, right here in your browser — one editor at a time. The first is the optional Top of Prompt editor and the last is the optional Bottom of Prompt editor, and the app's numbered prompt sections sit between them.
The Top of Prompt editor — the optional block that sits above the Persona editor. Switch it on and TPEE keeps a five-line Session Number heading at the top of the box; type your own framing below it, watch the live quality indicator re-score on every keystroke, and open the 📋 Quality Guidance dropdown
● GREEN: Concise, specific content that sets the stage for the entire prompt.
● YELLOW: Generic or repeated opening text.
💡 TIP: Content here is shown ABOVE the Persona section. TPEE keeps the five-line Session Number heading at the top: "This is Session Number: NNNN", then "The Project Prefix is "PREFIX"". NNNN is the number in your file name and it follows CREATE NEXT PROMPT, NNNN-1 is the session before it, the first Read line names that session's chat and action log, the second names this session's own session-start record, and the fifth line quotes the Working Directory and says the work stays inside it; your own text below the heading is never touched.
This interactive replica of the app's Top of Prompt editor works exactly like the real thing — the same live quality indicator (✗ red Poor, ⚠ yellow Needs Work, ✓ green Good) that re-scores on every keystroke with the app's own rule for this block (5 words or more scores Good, 2 or more Needs Work), the same 📋 Quality Guidance text and colours, and a working 📋 Copy Top of Prompt to Clipboard button. It is the box the app draws above the Persona editor, and the text in it is copied to the clipboard as part of the whole prompt — Top first, then the thirteen numbered sections, then Bottom. One honest difference — in the app the five-line heading follows your file name and moves with CREATE NEXT PROMPT, and the box is not saved with a prompt; this browser replica shows the heading of one real session (0742) and keeps your text only while the page is open.
The Persona editor, exactly as in the real app — type your own persona, or click the 📋 -- Select or Type -- button to pick from 275 ready-made personas, and open the 📋 Quality Guidance dropdown to see what makes it score GREEN
● GREEN: Be specific about expertise - 'You are an expert Rust programmer with 10 years experience in systems programming and embedded development' vs vague 'You are helpful'
● YELLOW: Basic role definition - 'You are a programming assistant' or 'Act as a code reviewer'
💡 TIP: Think about what specific knowledge, experience, or perspective the AI should have for your task.
This interactive replica of the app's Persona editor works exactly like the real thing — the same 275-persona library in the 📋 -- Select or Type -- dropdown (type in the filter box to narrow it; when exactly one name matches, the app applies it straight away), the same live quality indicator (✗ red Poor, ⚠ yellow Needs Work, ✓ green Good) that re-scores on every keystroke with the app's own rules, the same 📋 Quality Guidance text and colours, and a working 📋 Copy Persona to Clipboard button. One honest difference — the app saves your persona into your prompt file; this browser replica keeps it only while the page is open.
The Instructions editor, exactly as in the real app — type your own instructions, watch the live quality indicator re-score on every keystroke, and open the 📋 Quality Guidance dropdown to see what makes it score GREEN
● GREEN: Use precise action verbs - 'Analyze the memory management patterns and explain potential memory leaks' vs 'Make the code better'
● YELLOW: Basic actions - 'Review this code' or 'Explain how this works'
💡 TIP: Start with strong verbs: analyze, create, design, implement, optimize, debug, refactor, document. Be specific about what you want done.
This interactive replica of the app's Instructions editor works exactly like the real thing — the same live quality indicator (✗ red Poor, ⚠ yellow Needs Work, ✓ green Good) that re-scores on every keystroke with the app's own rules (start with a strong action verb like analyze, create or explain, be specific, and avoid vague words like good or nice), the same 📋 Quality Guidance text and colours, and a working 📋 Copy Instructions to Clipboard button. One honest difference — the app saves your instructions into your prompt file; this browser replica keeps them only while the page is open.
The Context editor, exactly as in the real app — type your own context, watch the live quality indicator re-score on every keystroke, and open the 📋 Quality Guidance dropdown to see what makes it score GREEN
● GREEN: Relevant background info - 'This is a real-time embedded system with 64KB RAM constraints, using Rust no_std' vs generic context
● YELLOW: Basic context - 'This is for a web application' or 'Working on a school project'
💡 TIP: Include technical constraints, target environment, performance requirements, or specific domain knowledge needed. Keep it focused and relevant.
This interactive replica of the app's Context editor works exactly like the real thing — the same live quality indicator (✗ red Poor, ⚠ yellow Needs Work, ✓ green Good) that re-scores on every keystroke with the app's own rules (good context is informative but concise: the app scores word count against text density), the same 📋 Quality Guidance text and colours, and a working 📋 Copy Context to Clipboard button. One honest difference — the app saves your context into your prompt file; this browser replica keeps it only while the page is open.
The Technical Specs editor, exactly as in the real app — type your own technical specifications, or click the 📟 -- Select Hardware -- button to pick from 230 development boards and auto-fill the specs, watch the live quality indicator re-score on every keystroke, and open the 📋 Quality Guidance dropdown to see what makes it score GREEN
● GREEN: Detailed technical requirements - 'ARM Cortex-M4 @ 168MHz, 1MB Flash, 192KB RAM, SPI interface @ 10MHz max, <100µs interrupt latency, MISRA-C compliance'
● YELLOW: Basic specs - 'Microcontroller with 1MB memory, fast SPI' or 'Embedded system requirements'
💡 TIP: Include specific hardware (processor, memory, interfaces), performance constraints (timing, power), standards compliance (MISRA, ISO), and environmental requirements (temperature, EMI). Use exact numbers and units.
This interactive replica of the app's Technical Specs editor works exactly like the real thing — the same 🔧 Hardware / Development Board Selection with 230 boards (type in the Filter box to narrow the list; when exactly one board matches, the app selects it straight away), the same board photos (the app's own bundled photos, resized for the web — click a photo to enlarge it), the same auto-fill that writes the selected board's platform, MCU, features and best-for into the editor, the same live quality indicator (✗ red Poor, ⚠ yellow Needs Work, ✓ green Good) that re-scores on every keystroke with the app's own rules (specific hardware, constraints, exact numbers and units), the same 📋 Quality Guidance text and colours, and a working 📋 Copy Technical Specs to Clipboard button. Two honest differences — the app saves your specs into your prompt file while this replica keeps them only while the page is open, and the app's 📂 Open Image Folder button (it opens Windows Explorer) does not exist on the web.
The Format editor, exactly as in the real app — specify exactly how you want the output formatted, watch the live Quality: indicator re-score on every keystroke, and open the 📋 Quality Guidance dropdown to see what makes it score GREEN
● GREEN: Precise format specs - 'Return as JSON with fields: {"issue": string, "severity": 1-5, "fix": string}' or 'Markdown with ## headers, code blocks, and bullet points'
● YELLOW: Basic format - 'JSON format' or 'As a numbered list'
💡 TIP: Specify exact structure, field names, data types, headers, or markup. Think about how you want to consume the output.
This interactive replica of the app's Format editor works exactly like the real thing — the same fixed-height monospace editor, the same live Quality: indicator (Poor / Needs Work / Good) that re-scores on every keystroke with the app's own rules (name a structure like JSON, a table or a bullet list, plus specifics like headers, sections or markdown), the same 📋 Quality Guidance text and colours, and a working 📋 Copy Format to Clipboard button. One honest difference — the app saves your format into your prompt file; this browser replica keeps it only while the page is open.
The Audience editor, exactly as in the real app — describe who will read or use the output, watch the live Quality: indicator re-score on every keystroke, and open the 📋 Quality Guidance dropdown to see what makes it score GREEN
● GREEN: Specific audience with experience level - 'Senior embedded systems engineers familiar with ARM Cortex-M and real-time constraints' vs generic 'developers'
● YELLOW: Basic audience - 'C++ programmers' or 'Students learning Rust'
💡 TIP: Consider experience level, domain knowledge, technical background, and what they already know vs. what needs explanation.
This interactive replica of the app's Audience editor works exactly like the real thing — the same fixed-height monospace editor, the same live Quality: indicator (Poor / Needs Work / Good) that re-scores on every keystroke with the app's own rules, the same 📋 Quality Guidance text and colours (a specific audience with an experience level scores best), and a working 📋 Copy Audience to Clipboard button. One honest difference — the app saves your audience into your prompt file; this browser replica keeps it only while the page is open.
The Tone editor, exactly as in the real app — describe the communication style you want, watch the live Quality: indicator re-score on every keystroke, and open the 📋 Quality Guidance dropdown to see what makes it score GREEN
● GREEN: Specific communication style - 'Technical and precise, like code review comments with constructive suggestions' vs generic 'professional'
● YELLOW: Basic tone - 'Formal and detailed' or 'Casual and friendly'
💡 TIP: Think about formality level, technical depth, teaching style, and emotional approach. Match the tone to your audience and purpose.
This interactive replica of the app's Tone editor works exactly like the real thing — the same fixed-height monospace editor, the same live Quality: indicator (Poor / Needs Work / Good) that re-scores on every keystroke with the app's own rules, the same 📋 Quality Guidance text and colours (a specific communication style scores best), and a working 📋 Copy Tone to Clipboard button. One honest difference — the app saves your tone into your prompt file; this browser replica keeps it only while the page is open.
The Data editor, exactly as in the real app — specify your data sources, references or documentation, watch the live Quality: indicator re-score on every keystroke, and open the 📋 Quality Guidance dropdown to see what makes it score GREEN
● GREEN: Specific data sources - 'Use ARM Cortex-M4 reference manual section 4.3.2 and MISRA-C 2012 Rule 11.3 for pointer casting guidelines' vs generic references
● YELLOW: Basic data - 'Company coding standards' or 'Project requirements document'
💡 TIP: Include specific standards, documentation sections, code repositories, or datasets. Be precise about version numbers and relevant sections.
This interactive replica of the app's Data editor works exactly like the real thing — the same fixed-height monospace editor, the same live Quality: indicator (Poor / Needs Work / Good) that re-scores on every keystroke with the app's own rules, the same 📋 Quality Guidance text and colours (specific data sources with exact versions and sections score best), and a working 📋 Copy Data to Clipboard button. One honest difference — the app saves your data into your prompt file; this browser replica keeps it only while the page is open.
The Example(s) editor, exactly as in the real app — show concrete input/output examples, watch the live quality indicator re-score on every keystroke, and open the 📋 Quality Guidance dropdown to see what makes it score GREEN
● GREEN: Clear input/output pairs - 'Input: unsafe { ptr.read() } Output: {"issue": "Unsafe pointer dereference", "severity": 4, "fix": "Add null check before dereferencing"}'
● YELLOW: Basic examples - 'For example: check memory allocation' or 'Like analyzing malloc() calls'
💡 TIP: Show concrete before/after examples. Demonstrate the exact input format and desired output structure. Multiple examples show edge cases.
This interactive replica of the app's Example(s) editor works exactly like the real thing — the same live quality indicator (✗ red Poor, ⚠ yellow Needs Work, ✓ green Good) that re-scores on every keystroke with the app's own rules (it looks for concrete input/output pairs or phrases like for instance and such as, and rewards several examples), the same 📋 Quality Guidance text and colours, and a working 📋 Copy Example(s) to Clipboard button. One honest difference — the app saves your examples into your prompt file; this browser replica keeps them only while the page is open.
The Graphics editor, exactly as in the real app — describe the diagrams and visual elements you want, watch the live quality indicator re-score on every keystroke, and open the 📋 Quality Guidance dropdown to see what makes it score GREEN
● GREEN: Specific visual requirements - 'Generate UML sequence diagram showing memory allocation flow with timing annotations and error paths' vs generic 'make a diagram'
● YELLOW: Basic graphics - 'Flow chart of the process' or 'Simple block diagram'
💡 TIP: Specify diagram type, content details, annotations, colors, layout, and purpose. Think about what visual elements will clarify your technical content.
This interactive replica of the app's Graphics editor works exactly like the real thing — the same live quality indicator (✗ red Poor, ⚠ yellow Needs Work, ✓ green Good) that re-scores on every keystroke with the app's own rules, and the same 📋 Quality Guidance text and colours (a specific diagram type with content, annotations and purpose scores best). Two honest notes — the Graphics section has no copy button in the app (mirrored here exactly), and the app saves your graphics details into your prompt file while this browser replica keeps them only while the page is open.
The MCP Servers editor, exactly as in the real app — note the MCP server configurations your prompt should cite, watch the live quality indicator re-score on every keystroke, and open the 📋 Quality Guidance dropdown to see what makes it score GREEN
● GREEN: Specific MCP server configurations with endpoints and capabilities
● YELLOW: Basic server names or generic configurations
💡 TIP: Configure Model Context Protocol servers for enhanced AI capabilities and tool integration.
This interactive replica of the app's MCP Servers editor works exactly like the real thing — the same live quality indicator (✗ red Poor, ⚠ yellow Needs Work, ✓ green Good) that re-scores on every keystroke with the app's own rules, the same 📋 Quality Guidance text and colours, and a working 📋 Copy MCP Servers to Clipboard button. Two honest notes — this section is configuration text for your prompt: TPEE itself never connects to any MCP server (it is 100% offline by design), and the app saves your text into your prompt file while this browser replica keeps it only while the page is open.
The Verification of Results & Outcome editor, exactly as in the real app — say how you will check the result and what good and excellent look like, watch the live quality indicator re-score on every keystroke, and open the 📋 Quality Guidance dropdown to see what makes it score GREEN
● GREEN: You name what GOOD and EXCELLENT look like AND the check you will run - 'I will verify your work by running the module on Ubuntu 24.04 and comparing the three sample outputs with section 4; good is all three matching, excellent is all three matching with the reasons for each difference written down.'
● YELLOW: A check is named but no standard - 'I will run it and see if it looks right.'
💡 TIP: Start with 'I will verify your work by ...' and then add three things: WHAT you will check (a test to run, a file or page to open, a number to read, a person to ask), WHEN you will check it (after every step, at the end, before you send it on), and what GOOD and EXCELLENT look like - so the model knows what it is aiming at. A check you cannot describe is a standard the model cannot meet. Examples: 'I will verify your work by running cargo test and reading the pass count' / 'I will verify your work by comparing every price with the supplier PDF' / 'I will verify your work by asking three real users to sign up once, unaided.'
This interactive replica of the app's Verification of Results & Outcome editor works exactly like the real thing — the same live quality indicator (✗ red Poor, ⚠ yellow Needs Work, ✓ green Good) that re-scores on every keystroke with the app's own rules, the same 📋 Quality Guidance text and colours (naming what GOOD and EXCELLENT look like and the check you will run scores best), and a working 📋 Copy Verification to Clipboard button. One honest difference — the app saves this section into your prompt file; this browser replica keeps it only while the page is open.
The Agents editor, exactly as in the real app — define the AI agents your prompt should orchestrate, watch the live quality indicator re-score on every keystroke, and open the 📋 Quality Guidance dropdown to see what makes it score GREEN
● GREEN: Specific agent definitions with roles, capabilities, and workflows
● YELLOW: Basic agent names or simple configurations
💡 TIP: Define AI agents with specific roles, capabilities, and interaction patterns for complex task automation.
This interactive replica of the app's Agents editor works exactly like the real thing — the same live quality indicator (✗ red Poor, ⚠ yellow Needs Work, ✓ green Good) that re-scores on every keystroke with the app's own rules, the same 📋 Quality Guidance text and colours (specific agent definitions with roles, capabilities and workflows score best), and a working 📋 Copy Agents to Clipboard button. One honest difference — the app saves your agents configuration into your prompt file; this browser replica keeps it only while the page is open.
The Bottom of Prompt editor — the optional block that sits below the Agents editor. Switch it on and TPEE keeps a two-line closing instruction at the bottom of the box; type your own sign-off above it, watch the live quality indicator re-score on every keystroke, and open the 📋 Quality Guidance dropdown
● GREEN: Concise, specific closing content that wraps up the prompt.
● YELLOW: Generic or repeated closing text.
💡 TIP: Content here is shown BELOW the Agents section. TPEE keeps the two-line closing instruction at the bottom of this box: the first line asks the model to write up this session's chats and actions (the ones you typed) and names the file to save them in, the second asks for the record the NEXT session needs and names its file. The two numbers follow your file name and move with CREATE NEXT PROMPT; your own text above them is never touched.
This interactive replica of the app's Bottom of Prompt editor works exactly like the real thing — the same live quality indicator (✗ red Poor, ⚠ yellow Needs Work, ✓ green Good) that re-scores on every keystroke with the app's own rule for this block (5 words or more scores Good, 2 or more Needs Work), the same 📋 Quality Guidance text and colours, and a working 📋 Copy Bottom of Prompt to Clipboard button. It is the box the app draws below the Agents editor, and the text in it is copied to the clipboard as part of the whole prompt — Top first, then the thirteen numbered sections, then Bottom. One honest difference — in the app the two closing lines follow your file name and move with CREATE NEXT PROMPT, and the box is not saved with a prompt; this browser replica shows the closing lines of one real session (0742) and keeps your text only while the page is open.
Real, unretouched screens of the app — the product is the proof. Click or tap any screen to expand it.
Every screen is a real 1080×2340 capture — click or tap any screenshot to expand it full screen, or browse all seven categories in the full gallery.
What do TPEE's functions actually do? Each one is shown as an interactive replica of the real application, right here in your browser — one function at a time.
The User's Manual button, click it to see a sample
This interactive replica of the User's Manual shows the complete manual exactly as it ships with the app — the same three documents, the same table of contents. Download the app to always carry the latest edition with you.
The Learning menu's Open Learning Center button, click it to see a sample
This interactive replica of the Learning Center - TPEE Professional AI Course shows the complete course exactly as it ships with the app — the same 94 lessons and the same 282 quiz questions, the same window layout. Take a real quiz: it is graded exactly like in the app. One honest difference — the app saves student progress to disk; this browser replica keeps it only while the page is open. Or read three of the most-asked questions for free on the web: what prompt engineering is, what MCP servers are, and what an AI agent is. The whole course is online too: all 94 lessons, free to read.
The Learning menu's ClassRoom Presentation button, click it to see a sample
This replica shows the two presenting modes of the window the app ships: all three TV-MIRE projector cards with the PLUGE and safe-zone bars, and the lesson slides carrying the same 94 lessons and 282 quiz questions as the Learning Center. Present a lesson, click a bullet to highlight it, switch on 🗒 Lecturer Notes, or turn on ⌨ Keys (off by default) and drive the slides with the arrow keys, Space, Page Up / Page Down and Home / End. The window's third mode, 🗓 Course Organizer, is the lecturer's planner and is described beside this card: the course name and location, its start and end date and time, an editable day of lesson blocks and breaks, a Done tick with the recorded time for every bullet point and every lesson, an estimate of the hours and days the course will take — and a course calendar that asks which weekdays the course lectures on, which dates are days off, and how much allowance to leave for a course that keeps growing, then draws a 42-cell month grid and answers the planning question in one line: whether the days you have reserved are enough. Four honest differences: this replica draws the two presenting modes, not the Course Organizer; it saves nothing — the lesson-list width and the notes divider reset when you close it, while the app keeps both until you close TPEE; Maximize fills this browser tab, not a projector screen; and it draws one dark slide, while the app's highlight band follows your theme. F1 help is Windows-only.
The PRD Innovator menu, click it to see everything it can do
This replica shows the whole PRD Innovator: the menu with New, Open and Save PRD and the four Quick Start rows; the Economic Sectors Day to Day Work family of one hundred and thirty-nine offices in thirty-seven sectors of activity, each sector switchable on or off; the seventeen smart blocks every office PRD carries; the PRD Editor window with its twelve sections and its Generate Prompt button; and the one-box search that finds any office by name, its summary or its sector. Click the rail on the left to walk through each part. One honest difference: this replica is read-only — it opens no file and writes nothing — and the app itself is fully offline.
The editor toolbar's OnBoarding toggle and the floating window it opens
TPEE opens with a 26-step checklist in a floating window, before you have read a word of the manual: the toolbar button reads Using OnBoarding until you switch it off. The steps are grouped in the order you actually work — Before you start (read the User's Manual, complete the lessons), the working environment (the Working Directory, the four Prefix, Prompts and TPEE Settings paths, File Name and Project Prefix), the prompt (the optional Top of Prompt editor, the thirteen sections, the optional Bottom of Prompt editor), the Prompt Enhancing Workflow, and the finishing moves (Preview, Clipboard-Clear all, Copy to Clipboard, paste into your chat window). Where TPEE can see a step for itself it says so beside the row — a folder is set or it is not, a section has text or it has not — and one button ticks every step TPEE can already see. Rows that are your own judgement carry no badge, because nothing in the program can see them and claiming otherwise would be a lie. Nothing you tick is written to disk: the ticks last for the run, and the only setting this feature remembers is the Preferences tick that decides whether the window is there next time you start TPEE. F1 help is Windows-only.
The IDE combobox, click it to see a sample
This interactive replica of the app's IDE combobox shows the 50 IDE profiles exactly as they ship with the app — the same list, the same selection behaviour, the same status line. In the real app the chosen IDE also drives prompt formatting, export, scoring and the optimization tips. The IDE list is updated weekly in the real app — download the app to always carry the latest IDE profiles with you.
The Model combobox, click it to see a sample
This interactive replica of the app's Model combobox shows the 182 AI models across 23 providers exactly as they ship with the app — the same list, the same type-to-filter box, the same provider groups, the same selection behaviour, the same status line. In the real app the chosen model also drives prompt formatting, scoring, the optimization tips and the PRD generator — and on first run the app pre-selects its default, Claude Fable 5. The model list is updated weekly in the real app — download the app to always carry the latest model profiles with you.
The Show API Limits button, click it to see a sample
This interactive replica of the app's API Character Limits panel shows the 182 AI models across 23 providers exactly as they ship with the app — the same provider columns, the same cards, the same pricing, the same newest-first order. Two honest differences: in the real app the coloured bar on each card fills with your live prompt's character count and shifts green → yellow → orange → red as you approach the model's limit (here it sits at 0%), and the gold frame follows your selected model (the app pre-selects Claude Fable 5 on first run). The limits and pricing are updated weekly in the real app — download the app to always carry the latest numbers with you.
The Show Kimi / Commands button, click it to see a sample
This interactive replica of the app's per-model command reference panel shows the same offline command sheets exactly as they ship with the app — the same 16 model-family sheets, the same tutorial, the same "Selected:" banner. The replica starts on Kimi K3, so the button reads "Show Kimi / Commands" and opens the "Kimi / Commands (reference)" window; pick any model in the Model combobox above and the button and the window follow automatically — Models / Commands change with the selected model, exactly like the real app (a GLM model now opens its own GLM sheet, and a Hermes model opens the Hermes sheet ). The command sheets are updated weekly in the real app — download the app to always carry the latest commands with you.
The Show Tips button, click it to see a sample
This interactive replica of the app's Optimization Tips panel shows the same context-aware tips exactly as they ship with the app — the same tip engine, the same four categories (📐 Structure, 🎨 Style, 📏 Length, ⚡ Features), the same colours. The tips are computed for the IDE and the model selected in the IDE and Model comboboxes above and change automatically with your selection, exactly like in the real app — try it: open the tips, then pick another IDE or model above and watch the window follow (on first run the app itself pre-selects Cursor + Claude Fable 5). The optimization tips are updated weekly in the real app — download the app to always carry the latest tips with you.
The 📋 Projects Prefixes button, click it to view the Projects Prefixes Library window
This interactive replica shows the app's File Name / Project Prefix toolbar row and the 📋 Projects Prefixes Library window exactly as they ship with the app — the same fields, the same defaults (File Name "prompt.txt", Project Prefix "T1042CW"), the same Add / quick-add / select / remove behaviour, the same status messages. Everything works: type a prefix, add it to the library, click a saved prefix to load it into the Project Prefix field, remove one with the 🗑 button — saved prefixes name your files PREFIX_Pmt_NNNN.txt (e.g., T1042CW_Pmt_0001.txt). One honest difference — the app saves your library to its preferences file so it survives restarts; this browser replica keeps it only while the page is open.
0 sections found
Offline tutorial system: lessons, quizzes, students, scores. No AI call, no MCP server, no external connection.
TV-MIRE - Colour Bars + ALIGNMENT TARGET (offline, no network, no AI call)
Lecturer Notes is on. Make your browser window taller to see the notes.
The PRD Innovator turns a rough idea into a structured Product Requirements Document. Open the menu and pick how you want to begin.
New PRD asks what kind of platform you are building and opens a document already shaped for it. Open and Save PRD read and write your own PRD files. The four Quick Start rows skip the form and begin straight away, each naming the PRD after the platform type.
The Quick Start rows ask what kind of software you are building. The Economic Sectors Day to Day Work rows ask what kind of office is doing the work. Each one opens a PRD already filled in with that office's daily requirements — the recurring tasks, the workflow, the deadlines, the records and the compliance rules.
139 of 139 offices are switched on across 37 sectors of activity.
The offices are filed under thirty-seven sectors of activity. Switch a sector on or off with the tick beside it and its whole shelf appears or disappears; two buttons turn every sector on, or every sector off, in one click. The whole tree sits in its own scroll area, so it stays usable as the family keeps growing.
Each Day to Day Work PRD ends its Requests the Assistant Will Receive section with seventeen blocks that turn a description into a brief an office can actually hand to an assistant:
Every block is written in that office's own terms — a pharmacy, a quarry, a law firm and a bakery each get their own words — so the template is a real brief rather than a description.
Any PRD opens in the PRD Editor window, a real, movable, resizable window with Maximize, Minimize and Restore. Its twelve sections are:
Each section carries a quality indicator and a character count, and the window closes with a Requests the Assistant Will Receive section. A Generate Prompt button turns the whole document into a ready-to-paste prompt, and Save, Save As and Open write and read your PRD files in the folder you chose under the Location panel.
With one hundred and thirty-nine offices, browsing the tree is fine when you know the sector and hopeless when you do not. One box searches every office in every sector at once.
3 office(s) match 'pharmacy' - by office name, summary or sector name - click one to open its PRD
A hit says why it matched — the office name, its summary or its sector — and where it sits inside its own sector. Above the box, a Today's office to try row opens a different office every day, in date order, so the whole family gets seen.
Nothing you type into a PRD leaves your machine. The app makes no outbound call except the two you switch on yourself: the update check and Send Feedback.
Current prefix: T1042CW
No saved prefixes yet. Add one above.
Everything in TPEE exists to answer one question: is this prompt ready? The score tells you. The sections show you why.
The Use Prompt Enhancing Workflow button turns prompt writing into a guided conversation: TPEE wraps your prompt between a Pre-Prompt and a Post-Prompt, you paste the bundle into any LLM chat, and the model helps you improve the prompt before you ever use it. How it works ↓
Prominent featurePersona, Instructions, Context, Technical Specs, Format, Audience, Tone, Data, Examples, Graphics, MCP Servers, Verification of Results & Outcome, Agents — thirteen sections, each with a GREEN/YELLOW/RED readiness indicator, rolled into a 0–100 quality score.
182 model profiles across 23 providers, with pricing, context windows, and API character limits — so the prompt you write fits the model you'll actually run.
Format once, export anywhere: 50 IDE profiles including Cursor, VS Code variants, Claude Code, Kiro, and Devin Desktop.
A local prompt library with version history and automatic backups keeps every draft safe on your machine.
PRD Innovator turns rough ideas into structured requirements.
Claude Team Designer and the Team Management suite organize multi-agent work.
94 lessons and 282 quiz questions, built in. TPEE doesn't just hold your prompts — it teaches the craft.
A catalogue of development boards with photos, for prompt engineers who also push bits.
High-contrast, color-blind-support, and low-vision themes make the editor usable by everyone on the team.
TPEE runs from your USB stick, so you can learn anywhere you go: insert the USB stick into any Windows-compatible computer, double-click the TPEE.exe file on it (no installation required) and continue learning on the go. Your learning progress is kept on the USB stick — nothing is installed on the computer you plugged it into.
Prominent featureDon't just write a prompt. Have a conversation with the LLM about it first. One button in the top panel guides you through five steps using local files and your clipboard. TPEE never contacts an LLM; you drive the conversation.
Pre-Prompt + Your Prompt + Post-Prompt → clipboard → LLM chat → TPEE_Pmt_0001_Enhanced.txt100% local: marker lines frame your prompt like delimiters in a serial protocol, companion files live next to your prompt, and the only transport is your clipboard. No network, no account, no middleman.
PRD Innovator
The PRD Innovator's second family of one-click starts asks what kind of office is doing the work, not what kind of software you are building. thirty-seven sectors of activity, one hundred and thirty-nine offices, and every office opens a PRD that is already filled in with its daily requirements - then names the number it lives by, when to stop and hand back to a person, what the assistant must never do, what must happen at month end, where the office will be in three to five years and what the assistant must do first thing each morning - nineteen smart blocks per office. The whole family, every sector and every office card, is on its own page so this page stays quick to read.
Built for individuals, students, educators, and teams.
The full editor, scoring, and IDE export on your own machine — no account required to write.
Full app, 4 months of updates. Choose it from the pricing section and pay by card — no approval step.
USD $49 · one-timeFull app, 4 months of updates. Choose it from the pricing section and pay by card — no approval step.
USD $49 · one-timeTeam Management (shared templates, task assignment, team canvases) is built into the app. The team plan is not on sale yet — see pricing for current plans.
A development-board catalogue with photos, for engineers who also push bits.
94 lessons and 282 quiz questions, built in. TPEE doesn't just hold your prompts — it teaches the craft.
94 lessons · 282 quiz questions · included in every plan
Every plan is the full app. These are the numbers in the build you download today.
Offline by design: no account, no telemetry, and no call home beyond the release check and the feedback form you choose to use. One-time purchase, 14-day refund, Toptronic® Lifetime Warranty.
TPEE is the productivity tool of choice for all AI work, and especially for people who keep at it. Here is why, in plain terms.
One-time purchase, 14-day refund, Toptronic® Lifetime Warranty. Windows 10 and 11. Built for people who use AI every day, and for the long term.
Code-signed releases are published every two weeks. Information about builds we have not yet signed is published for reference, because it is useful to see what is coming.
What you are entitled to under the maintenance plan is the code-signed release, and it arrives on that schedule — not every day.
Code-signed is what you download. Nothing unsigned is ever offered for sale or for download.
One-time purchase. Updates are included with every plan — no subscriptions.
Prices are in US dollars, and Stripe charges the USD amount. The figure under each plan is an approximate local-currency equivalent for — your own bank converts it, at its rate.What happens after you pay: every plan is a one-time purchase — USD $49, $99 or $299 — the app keeps working forever, and every plan carries a 14-day refund, no questions asked.
USD $49 one-time
Approx. local equivalent: — you are charged USD $49 by Stripe.
Buy it now · USD $49 once, no approval step, no subscription
USD $99 one-time
Approx. local equivalent: — you are charged USD $99 by Stripe.
One-time USD $99 · 6 months of updates · the app keeps working forever after
USD $299 one-time
Approx. local equivalent: — you are charged USD $299 by Stripe.
One-time USD $299 · 12 months of updates · 14-day refund, no questions asked
USD $299 one-time
Approx. local equivalent: — you are charged USD $299 by Stripe.
One-time USD $299 · delivered by email to the recipient · 12 months of updates
Not sure which one is you? Find your line:
The plans do not differ in the app. Every plan is the full app — what changes is how long updates continue after you buy (4, 6 or 12 months of updates) and how many people may use one licence (1 user on Starter, 1 commercial user on Professional). When the update window ends the app keeps working; you simply stop receiving new builds.
No free plan — every plan helps cover the infrastructure it runs on.
Accepted beta testers get 30% off the Professional plan with code BETA30 — see the beta program.
Put the price in context: ChatGPT Plus and Claude Pro are $20 a month — $240 a year, forever. TPEE is a one-time $99 (Starter) and keeps working after the 6 months of updates. A single afternoon of wasted API calls costs more than the licence.
Refunds: within 14 days of purchase, no questions asked. The refund is paid through Stripe minus what the refund costs us: a flat fee of 15% of the amount plus USD 5, together with administrative, accounting, financial, exchange-rate, legal and other processing fees charged to us by your purchase and your refund instruction. The full wording is on the terms of purchase page. Just email us from your order address.
Made by Toptronic® Limited, Hong Kong — a small team who answer their own email. Read who we are.
Any defect of the features of the product purchased from us, and during the maintenance period, but additionally, any feature of the product purchased and during the maintenance period, which has a defect when running on your hardware, we warranty we will make it work to satisfaction during the lifetime of the product. For example, if you purchased a TPEE Pro with 12 months of maintenance, the initial product and all its subsequent releases during those months of maintenance are covered, and we warrant that we will ensure the product purchased and the releases covered during the maintenance, works as expected on your hardware during the LifeTime of the product.
Use the feedback form on this page, or the feedback form in the app (Help > Send Feedback), and select the Warranty Claim category. Explain what is not correct and how to reproduce it, then send your warranty claim.
We sent early alpha and beta builds to engineers working at these companies. They emailed us feedback that shaped TPEE, and asked us not to name them individually, so we thank them here instead. More testers are with us now, and this wall will grow.
Straight answers, no fine print.
Yes — the app works offline, and sends nothing you did not ask to send. The only two paths out are Help > Check for Updates (which also runs once at start-up until you untick 'Check for Updates at Start up') and Help > Send Feedback. No telemetry, no account needed to write prompts. Verify with your firewall; we encourage it. (The website and Stripe checkout are online, obviously.)
Yes - it is safe, and you can check it yourself in a minute. Every release we sell is code-signed with an EV certificate in the name of Toptronic Ltd. SmartScreen can still show a warning the first time it sees a brand-new signed installer, because a file earns its reputation with Windows over time, not the moment it is signed - so the warning says nothing about the file. To continue, click More info, then Run anyway. Before you run it, confirm the download is ours: the published file name and its SHA-256 should match, and the certificate should name Toptronic Ltd. If the name, the publisher or the hash does not match, stop and email us instead. Step-by-step verification is on our Security page.
No — running the infrastructure costs money, so every plan is paid. The Student plan is USD 49.00 and includes 4 months of updates: choose the plan on the pricing section and pay by card — no approval step.
Each of the 13 prompt sections is checked for completeness and internal consistency, shown as GREEN/YELLOW/RED, and rolled into a 0–100 score. It won't write the prompt for you — it tells you when you've done the work.
50 profiles, including Cursor, VS Code and its variants, Claude Code, Kiro, and Devin Desktop — plus a general formatter if your tool isn't listed.
182 model profiles across 23 providers, with pricing, context windows, and API character limits. TPEE doesn't call these models for you — it helps you write prompts that fit them.
Both. Same app, same build: MSI for a normal Windows install, ZIP for run-from-anywhere (no admin rights needed).
Windows 10 and 11 only, for now. It's a native Rust/egui app, and we'd rather support one platform properly than three poorly.
Accepted beta testers get 30% off the Professional plan (code BETA30) in exchange for short monthly feedback. Details and application: beta program.
Compare it to a ChatGPT Plus or Claude Pro subscription — see the numbers on the pricing page.
TPEE sends nothing you did not ask to send. The only two paths out are Help > Check for Updates — which also runs once at start-up until you untick 'Check for Updates at Start up' — and Help > Send Feedback, which waits for you to press Send. No MCP connections, no analytics, no account, nothing else. You can verify that with your own firewall — we encourage it.
Receive updates — enter your details and confirm by email. No spam, unsubscribe any time.
New TPEE builds, download links, and update news — from [email protected].
Latest new features and the TPEE newsletter — from [email protected].
Buy TPEE Professional as a gift. The recipient receives the licence by email with the message “This is the Gift of the Future” and your name as the giver.
We need your first name, surname and email so we can send your licence, your receipt and your download link. Payment is processed securely by Stripe.