Product case study · July 23, 2026
I burned through my Descript credits, then built the workflow I needed
A narrow timeline for overlays and title cards replaced the expensive part of my editing loop. Here is how to find and build your own focused tool.

AI coding makes a focused internal tool possible when a broad subscription is a poor fit. Start with the repeated job, prove that the smaller tool saves time or money, and test outside demand separately.
I did not set out to replace Descript. I wanted to make videos without doing the same visual editing work by hand every time. Then I looked at the credit screen.
During the original build, I used the 1,500 AI credits included with my Descript plan in seven days. The account screen also showed 2,507 of 4,000 top-up credits already used. The media-minute allowance was nowhere near its limit. The expensive part was asking the editor to do AI work, then asking it again when the result needed another pass.

That is not an argument that Descript is bad. It does a lot. It is an argument that I did not need most of it.
For the videos I was making, the useful loop was much smaller: review a talking-head edit, see where a title scene, callout, or B-roll insert belongs, and place it on a timeline. I did not need a broad AI editing product deciding what to generate on every pass. I needed a dependable way to make a few types of visual edit.
This was the prompt that started it:
can you read the descript-hyperframes skill and make this into a full fledged app - or at least i want to see the overlays on a timeline of the video and along with the scene transitions or other footage so this way i can know what sort of edits are in this video. basically make the UI like descript as much as possible. I want you to design the specifications. use modern frameworks, make a todo document, then build it here - make the ui can and nice looking like https://www.tapnow.ai/
It was a long, slightly unreasonable prompt. The request was clear, though: show the visual edit plan on a timeline, write down the product shape first, then build a polished interface instead of an internal tool that only I could tolerate.
Three hours later, I had Cutmap. That was the original prototype milestone, not a promise that a production editor takes an afternoon.
Find the expensive repeated step
The useful starting point was not “build a video editor.” It was the moment I kept paying to repeat: place a small set of visual edits against a finished talking-head video, review the timing, and move them when the cut changed.
You can use the same test on your own work:
- Track one task for a week and count how often it repeats.
- Save the exact inputs, the finished output, the time spent, and any usage charges.
- Circle the smallest step that causes most of the cost or frustration.
- Write a build brief for that step only. Everything else goes on a “not yet” list.
This produces a much better coding prompt. The AI gets a real input, a visible output, and a boundary. You also get a fair way to judge the result. If the tool cannot complete that one job on real files, more features will not rescue it.
The editor I actually needed
Cutmap is not a full Descript replacement. It is a focused review and placement tool for the part of my workflow that had become expensive.
The main screen has a video preview in the middle, a media bin on the left, an inspector on the right, and a multi-track timeline below. Title scenes, callout overlays, B-roll, and the main video sit on separate tracks. Selecting an item shows its in and out point, duration, source, accent, and placement controls.

It is deliberately basic. I did not need to recreate every button in a mature editor. I needed to make the important edit visible and editable.
When I am reviewing a video, I want to answer a few practical questions: What appears at this moment? Is it a title scene, a chroma-keyed callout, or B-roll? How long does it stay on screen? Does the edit still make sense after a scene transition shifts the timeline?
The original overlay workflow already had a clear sequence: read the transcript, plan visual moments, render the assets, place them, and verify the result. Cutmap turns that sequence into a screen I can inspect. It makes the edit plan concrete instead of leaving it spread across prompts, filenames, and a credit meter.
What we deliberately did not build
The phrase “SaaS is dead” is a headline, not a market forecast. Descript has collaboration, transcription, recording, publishing, media management, and far more than I rebuilt in an afternoon. Those features are real work.
I skipped them because they were not the bottleneck.
The videos needed title cards, callouts, and occasional B-roll. They needed an editor that could show those edits against the underlying footage and let me move them when pacing changed. That is a much smaller problem than building an AI video platform.
The project browser makes that trade-off obvious. It lists videos with their edit counts and marks projects that only have imported assets rather than a base composition. That is enough information to open the right project and see what is missing.

There is still plenty this version does not do. That is fine. A thin tool has room to be honest about its edges.
The credit problem changed the build decision
The screenshot records the balance that prompted this build; it does not break down the cost of each operation. It also is not a current plan quote. Check Descript’s plan comparison against your own account before making a subscription decision.
Descript’s usage documentation, checked November 17, 2026, separates media minutes for uploads and recordings from AI credits for AI features. Underlord requests can vary in cost, and chatting with it also uses credits. Sending work through Descript’s API or MCP still uses the same allowances.
Before building anything, open Settings, select the relevant drive, and inspect Usage. Match a costly run to the task you actually wanted done. A new interface around the same paid operation will not remove that operation’s cost. The useful saving comes from changing which work needs AI at all.
Building the smaller tool was not free. It took time, a clear prompt, and enough specificity to avoid a generic dashboard. But the scope was finally under my control. I could make the interface care about overlay timing because overlay timing was the job.
AI makes it cheaper to build a tool around a specific workflow. It does not erase the value of polished software, support, collaboration, or reliability. It does make a bad fit much easier to walk away from.
Descript still makes sense for people who need its whole product. I needed a place to review and place visual edits without watching another credit counter climb. For that job, Cutmap is enough.
Give the coding agent a timing contract
“Make it like Descript” was useful visual shorthand. For a repeatable build, I would give the agent a much tighter job: show one existing video and let me place one existing overlay. Get that working before adding more tracks.
Here is an authored practice brief you can adapt for Hermes or Claude Code. It is a proposed exercise, not a newly tested Cutmap feature set. Use a copy of a short video and a transparent PNG you have permission to use; keep the originals untouched. You need a coding agent set up in a fresh project folder and a browser for reviewing its result. The small-project lesson covers the brief-to-build process.
Save this as SPEC.md:
Build a local overlay timing prototype in this project folder.
Input: one local video at least 20 seconds long and one transparent PNG.
Output: a preview and an exportable JSON edit plan; no rendered video yet.
Let me choose the files, play/pause, seek, and enter start/end times.
Use seconds on the base video's timeline. An overlay is visible when
start <= playback time < end. Reject negative starts, end <= start,
and any end beyond the loaded video's duration.
Begin with one overlay from 5.0 to 8.0 seconds, fixed in the lower right.
Show its start, end, and duration next to the preview.
Export the source filenames and numeric timing values as JSON.
Reimport that plan after I reselect the local media files.
If a filename differs, ask me to confirm the replacement.
If media is missing, show what I must select; do not silently omit it.
Do not add transcription, generated assets, accounts, uploads, or payments.
Keep media local. Document how to start the app and repeat the checks.
First explain the implementation plan and required dependencies.
The half-open interval matters: at exactly eight seconds, this overlay should be gone. “About here” is enough for a sketch; it is a poor rule for an editor.
After reviewing the plan, ask the agent to implement the brief and report which checks it actually ran. Open the result yourself and try these cases:
| Check | Expected result for this practice brief |
|---|---|
| Seek to 4.9, 5.0, 7.9, then 8.0 seconds | Hidden, visible, visible, hidden |
| Move the start to 6.0 and leave the end at 8.0 | Duration becomes 2.0 seconds; overlay stays hidden at 5.5 |
| Set the end equal to the start | Clear validation error; no invalid plan saved |
| Export, reload, reselect media, and import | The edited times return; the preview follows them |
| Import without choosing the overlay file | An explicit request for the missing media |
Ask the agent for a way to inspect those exact times if the scrubber is too coarse. Watch the interval during normal playback too. A correct label beside a frozen preview is still a broken editor.
If a check fails, give the agent the input and the mismatch: “The plan says 6–8 seconds, but the overlay appears at 5.5 after reimport.” Have it repair that behavior and rerun the checks without changing the expected results.
Keep export as a separate milestone. A JSON plan proves you can preserve editing decisions; it does not prove you can render them. Before using a later video exporter on paid work, inspect the rendered file outside the app for overlay timing, audio sync, and missing assets. Save the working plan before adding that machinery.
From an internal tool to paid work
Saving your own subscription cost is not the same as finding a business. The next test is whether another person has the same painful step and can use your solution without you operating every screen for them.
Start with a service, not a software launch. Ask one creator to send a real video and edit brief. Use the tool to deliver the finished overlay plan or timeline, then record how long the job took and where manual cleanup was still needed. If several people want the result, you can offer a repeatable editing package or a custom internal tool. A standalone product makes sense only when the workflow repeats across users and support does not erase the time you saved.
The proof is a small case study: the old process, the new process, five real runs, time and credit cost, the errors you found, and feedback from someone other than the builder. That is more useful than announcing that an afternoon prototype killed SaaS.
Continue with Build a side project with Hermes and Claude Code and The online business stack.
Source material
- Supplied Descript credit-usage screenshot from the Business-plan account screen.
- Supplied Cutmap project and editor screenshots.
- The supplied build prompt, which requested a Descript-like interface for timeline-based overlays, scene transitions, and other footage.
- Descript: Track and understand your media minutes and AI credits — checked November 17, 2026; usage categories, variable Underlord costs, account usage view, and API/MCP metering.
- Descript plan comparison — checked November 17, 2026; current plan reference, separate from the supplied historical account screenshot.
The November refresh adds a practice build brief and acceptance checks and clarifies credit metering. It does not report a new Cutmap test run or independently remeasure the original three-hour build.
Put this to work
Find a costly repeated workflow, cut the scope to one outcome, and use AI coding tools to build only the necessary path.
Try
Track one repeated task for a week, write down its inputs and finished output, then build the smallest tool that removes one manual step.
Prove it worked
Compare time, subscription or credit cost, error rate, and output quality across at least five real runs. Ask another user to try it without help.
Where it can pay
Start by selling the finished workflow or a custom internal tool to one user with the same problem. Consider software only after repeated demand.
Keep in view
- A narrow timeline for overlays and title cards replaced one expensive repeated step, not an entire editing suite.
- The useful product boundary came from a real workflow, known source files, and features the creator actually used.
- Cost savings justified the first build; outside demand would need separate validation.