Minto
Minto turns rough instructions into clear, well-organized prompts written in Markdown. It runs in your browser and needs no server.
- Role
- Product design + frontend development
- Outcome
- Clear, well-organized prompts that come out the same every time, even offline.
- Stack
- TypeScriptNext.jsDexie
What it is
Minto is a web app that turns rough, casual instructions into clear, organized prompts written in Markdown. Its heart is the prompt improver: it reads what you typed and builds a well-organized prompt, right in your browser, with no server needed. The same text always gives the same result.
The improver is plain TypeScript code that does not depend on any framework or storage. It runs fully in the browser, knows 13 kinds of tasks across four groups, and has three levels of detail. Around it is a simple workspace where you paste a prompt, pick options, and then view, edit, copy, and save the result. An optional AI rewrite can be turned on when a secure AI connection is set up, but the built-in improver works fully offline and is the default, private choice.
The problem and the fix
The problem
Vague prompts, uneven results
Messy instructions lead to unpredictable answers
Hard to say everything
Requirements, limits, and ways to check the result often get left out
Privacy and offline worries
Online-only tools see your text and stop working without internet
No shared format
Teams have no repeatable structure for prompts
The fix
Runs on your device, same result every time
The same input always gives the same Markdown, with no internet call
Picks out what matters
The action, topic, technologies, limits, and requirements
Markdown from templates
13 task types and 24 sections at light, standard, and detailed levels
Optional, checked AI rewrite
One secure HTTPS connection with a time limit, cancel option, and Zod checks when set up
What I did
- Studied the finished improver: how it reads text, sorts tasks, picks templates, chooses sections, and writes Markdown.
- Followed how the improver connects to the workspace, app settings, preferences, and saving on the device.
- Confirmed that the main flow uses no server, API, database, or outside service.
- Kept confirmed facts separate from reasonable guesses about the product.
- Wrote this portfolio story in the required structure without any unsupported claims.
How I designed it
- 01Entry point
Start from the single entry point
One function takes your text and options and returns what it found plus the Markdown
- 02Reading
Tidy up, then use word lists
Spaces and capital letters are tidied, then fixed lists find actions, tech, and limits
- 03Sorting
Score it, and admit when unsure
Word scores and trimmed endings give high, medium, or low confidence
- 04Structure
Let templates hold the structure
13 templates set the section order for light, standard, and detailed levels
- 05Clarity
Only skip what is empty
List sections with nothing in them are dropped, so there are no empty headings
Main features
Picking out the key parts
Finds the main action, the topic, any technologies from a fixed list, limits to respect, and requirements, whether they are written as a list or only hinted at.
Sorting tasks with a confidence check
Scores the text against word lists for each task type and gives a confidence score from 0 to 100. When the evidence is weak or two types are close, it falls back to a general template and suggests choosing the type by hand.
13 task templates in 4 groups
Covers coding tasks like bug fixes, new features, code review, cleanup, testing, and documentation; writing tasks like rewriting and summarizing; research tasks like investigating and comparing; and design tasks like reviewing a screen and writing image prompts.
24 reusable sections at three levels
Light gives one polished sentence, standard adds requirements and ways to check the result, and detailed builds a full structured document. Each template sets the section order, and lighter levels always follow the same order as the fuller ones.
Smart section choice
Skips list sections when there is nothing to put in them, so a prompt with no limits does not get an empty heading. Written sections get default text later on.
Quick polish and grammar fixes
Rewrites a prompt as one clear sentence that keeps your limits and meaning, with a separate grammar-only mode when no sections are chosen.
Automatic or manual control
Let Minto guess the task type or choose it yourself, turn any of the five visible sections on or off, and pick from 17 presets that set the type, level, and sections in one click.
One simple workspace
Two tabs, Enhance and Result, with a live character count, a notice when the result is out of date, a progress bar with a cancel button, and copy, export, and save buttons. It can retry after errors and asks before throwing away your edits.
Input checks and limits
Rejects empty prompts and allows up to 15,000 characters, so empty or oversized text never gets processed.
History and personal library
Good results can be kept in your history and moved into a personal library with folders and tags. Both are stored in IndexedDB on your device, with a history size limit you can set.
Tech Stack
TypeScript (strict)
the main language for the improver and the app, with shared types that keep the improver simple and predictable.
Next.js 16 (App Router) with React 19
runs the workspace, exports a static site for hosting, and provides a local test API route; the improver itself does not need either.
Prompt Engine module (pure TypeScript)
the self-contained improver: reader, sorter, templates, rules, and writer, with no React, Next.js, browser storage, or network code, so it always works offline and is easy to test.
Zod
checks what goes out and comes back when the optional AI rewrite is used, including size limits.
Zustand (with preferences provider)
stores your preferences, like default level, default task type, chosen sections, and history size, in cookies or local storage.
Dexie (IndexedDB wrapper)
saves history, saved prompts, and folders in your browser, with no server database.
Tailwind CSS v4, shadcn/ui, Radix UI
styling and accessible building blocks for the workspace panels and controls.
Verification scripts (Node.js)
hand-written test scripts that check every step of the improver and confirm the same input always gives the exact same output.
PWA and static export tooling
builds an installable offline version without server-only parts, so the improver works without internet.
The main flow needs no server, database, or outside service. The optional AI rewrite uses one secure, checked HTTPS connection with a time limit, a cancel option, and response checks, and only runs when it is set up.
Hard parts and how I solved them
- People write in many different ways
- Prompts vary a lot in wording and punctuation. Minto tidies up spaces and capital letters, uses fixed word lists for actions, technologies, and limits, and matches whole words instead of trying to fully understand language.
- Guessing the wrong task type with too much confidence
- With little evidence or two close matches, Minto could pick the wrong template. It measures both how far ahead the top match is and how strong it is, turns that into a high, medium, or low confidence level, uses the general template when confidence is low, and suggests choosing the type by hand.
- Matching different forms of a word
- To match words like failing and fails without a large language library, Minto trims a small set of word endings. This is kept simple on purpose and written down, so some unusual word forms are left unmatched instead of guessed.
- Avoiding empty headings
- A heading with nothing under it is confusing. Minto skips list sections when there is nothing to put in them, while written sections still get default text.
- Keeping templates consistent
- With 13 templates and three levels each, a mistake in section order would be easy to miss. Automatic checks make sure every level starts with Objective, has no repeated sections, and that lighter levels keep the same order as fuller ones.
- Same results versus creative results
- People expect the same prompt to give the same result, but may also want AI creativity. Minto keeps the two apart: the built-in improver runs instantly and predictably, while the AI rewrite goes through one secure, checked HTTPS connection with a time limit, a cancel option, and response checks.
How it works
- 1
You open the home page and land on the Enhance tab, with a greeting and a rounded text box.
The workspace is ready right away, with no sign-in needed.
- 2
You paste a rough instruction, watch the live character count toward the 15,000 limit, and can choose a task type, a detail level of light, standard, or detailed, and which sections to include.
A preset can set all of these in one click, and changing options after a result marks it as out of date.
- 3
Pressing Enhance runs the built-in improver instantly or, if set up, calls the AI service with your chosen options.
A progress bar appears and you can cancel, and empty or oversized prompts are rejected before any work starts.
- 4
When it succeeds, the view switches to the Result tab.
The Markdown shows in three views you can switch between: raw text, a formatted preview, and an editable version. A badge shows whether the result came from the built-in rules or from AI, and notes appear when Minto was unsure or two task types were close.
- 5
From there you can copy the result, export it as a Markdown file, improve it again with new input, or save it to your library.
Saving and history follow your history size setting, edits are tracked and confirmed before being replaced, and all history and library data stays on your device.
Results
- Works fully offline and privately, with no server, database, or outside service in the main flow; the improver's code has no links to frameworks, storage, or the network.
- Same results every time: running the same prompt and options again gives the exact same Markdown, confirmed by test scripts that run every step twice and compare the output byte for byte.
- Covers real use with 13 task types, 24 sections, 17 presets, three detail levels, and five sections you can turn on or off, plus checks that reject empty prompts and enforce the 15,000-character limit.
- IndexedDB saves history and your library on the device between visits, with no server and a size limit you control.
- No user numbers, speed tests, or business results are reported, because the code does not measure them.
- Offline use in different browsers, accessibility beyond the built-in components, and speed at the maximum character limit have not been tested by hand.
What I learned
What worked
- Keeping the improver fully separate from the rest of the app makes it easy to understand and test.
- Letting templates hold the structure, and using rules only to skip empty list sections, avoids ordering bugs and keeps the checks simple.
- Fixed word lists are easier to maintain than guessing, and make it obvious which technologies are not supported.
- Falling back to a general template when unsure builds more trust than confidently picking the wrong one.
- Test scripts that run everything twice and compare the output catch small inconsistencies that normal tests miss.
What could improve
- Grow the technology and limit word lists on purpose as new topics come up, instead of pretending to support them.
- Show low-confidence and close-match hints more clearly so people choose the task type themselves.
- Test offline use, accessibility, and speed at the 15,000-character limit across browsers and devices.
- Explain when list sections are skipped because they are empty, so people understand why a heading is missing.
Future ideas
- Keep the built-in improver instant and self-contained, and the optional AI rewrite as one secure HTTPS connection with a time limit and cancel option.
- Make the installable offline app and static export the default way to ship Minto, without server-only parts.
- Keep history and the library on the device, with size limits you control and easy export where it helps.
- Keep checking template order automatically as new task types or sections are added.

