Clone Support
Use case

Custom Internal App Builder

Describe an internal tool in plain English and your clone builds it, with a live preview link, a zip of the code and a README.

The problem

Small internal tools are rarely worth an engineering ticket, so teams live with messy spreadsheets and manual steps. A clone can turn a clear requirements list into a working first version in minutes, so you can test it, change it and decide whether it is worth keeping.

Custom Internal App Builder

Version 1.0.0 · Last updated 2026-10-22 · Difficulty: Beginner · Setup time: 5–15 minutes

Describe an internal tool in plain English. Your clone asks a few requirements questions, builds it with the Clone_Code skill, and gives you a live preview link, a zip of the code and a README.


1. Overview and value

Most teams have a list of small tools they wish they had: a deal scorecard, a pricing calculator, a simple intake form with a summary view, an inventory lookup. None is worth an engineering ticket. With this card your clone builds a working first version in minutes, and you refine it by chatting.

What you getDetails
Live preview linkValid for about 30 days
Zip of the codeDownload and keep; host or run it yourself
A READMEExplains what the tool does and how to run it
Change requestsKeep asking for changes on the same project for about 7 days
CostNot fixed; small tools are often modest in credits, larger builds cost more

Good first projects: deal evaluation scorecard, pricing calculator, intake form with summary dashboard, inventory lookup, project tracker, data-cleanup script.

The built app runs on its own. It does not call your CRM live unless you build that yourself. No scheduled task is needed for this use case.


2. Who it's for

  • Ops: intake forms, inventory lookups, trackers, cleanup scripts.
  • RevOps: deal scorecards, pricing calculators, data-cleanup scripts.
  • Sales: quick deal evaluation and quoting helpers.
  • Leadership: simple dashboards and trackers to test an idea.

3. How it works

code
 You: "Use Clone_Code to build an internal tool..."
   │
   ▼
 Clone walks you through the requirements template
   │  purpose · users · inputs · outputs · rules · data · look · must-haves
   ▼
 Clone + Clone_Code builds the tool (+ README)
   ▼
 Live preview link (about 30 days)  +  Zip of code  +  README
   │
   ▼
 You test with made-up data and known examples
   │      "Change X" / "Add Y"  (same project, about 7 days)
   ▼
 Download zip  ──►  Host it yourself (GitHub Pages / Netlify / Vercel)
                    or run the script locally
                    (IT review first if it will touch sensitive data)

4. What the clone does (and never does)

Does: walks you through requirements; builds the tool with Clone_Code; explains the calculations it used; lists assumptions and placeholders; gives a preview link, zip and README; applies change requests on the same project.

Never: asks for passwords, API keys or tokens; asks you to paste real customer data; hosts the tool for you or publishes it anywhere; connects the app to your CRM live unless you explicitly build that yourself.

5. Setup walkthrough

Step 1: Open REQUIREMENTS.md and confirm Clone_Code is available to your clone. Step 2: Give CLONE-INSTRUCTIONS.md to your clone and say: "Please set up this use case. Show me a plan first." It checks for Clone_Code and optionally saves the small Internal App Builder skill. Step 3: Say what you want to build, starting with "Use Clone_Code". The clone walks you through the requirements template. Step 4: Open the preview link and test with made-up data. Step 5: Check the calculations against known examples. Step 6: Ask for changes. Step 7: Download the zip, then host or run it yourself.

Requirements template

code
Use Clone_Code to build an internal tool.

1. Purpose (one sentence): {APP_PURPOSE}
2. Users (who, how many, technical level): {APP_USERS}
3. Inputs (fields, files, pasted data): {APP_INPUTS}
4. Outputs (screens, scores, tables, charts, downloads): {APP_OUTPUTS}
5. Rules and calculations (with 2-3 worked examples): {APP_RULES}
6. Data source (CSV export, pasted sample data, typed in): {DATA_SOURCE}
7. Look and feel (colors, logo, tone): {LOOK_AND_FEEL}
8. Must-haves: {MUST_HAVES}
9. Nice-to-haves (later): {NICE_TO_HAVES}

Use made-up sample data. Start with the must-haves only. Give me a README.

If you are not sure, just say what you want and the clone asks these nine questions one group at a time.

Example prompts

1. Deal evaluation scorecard

code
Use Clone_Code to build a deal evaluation scorecard for our sales team. Purpose: score an opportunity from 0-100 so managers can compare deals. Inputs: deal size, number of stakeholders engaged, budget confirmed (yes/no), timeline (days to close), competitor present (yes/no). Rules: weights are deal size 20, stakeholders 25, budget 25, timeline 20, competitor 10 (lose points if present). Show the score, a red/amber/green label (below 50 red, 50-74 amber, 75+ green) and a short "what would raise this score" list. Example check: a deal with all maximum inputs and no competitor should score 100. Clean modern look, navy and white. Must-haves: the scorecard form and result. Nice-to-have: compare up to 5 deals side by side.

2. Pricing calculator

code
Use Clone_Code to build an internal pricing calculator. Inputs: number of seats, plan (Basic, Pro, Enterprise), term (1, 2 or 3 years), optional onboarding package. Rules: list price per seat per month is {BASIC_PRICE}, {PRO_PRICE}, {ENTERPRISE_PRICE}; volume discount 5% at 50+ seats and 10% at 200+; multi-year discount 3% for 2 years and 6% for 3 years; any total discount above 15% shows "Needs manager approval". Output: monthly price, annual price, total contract value and a printable summary. Use placeholder prices I can edit in one settings section. Example check: 10 seats, Basic, 1 year, no discounts, equals 10 x {BASIC_PRICE} x 12.

3. Intake form with summary dashboard

code
Use Clone_Code to build an internal request intake page. Users: our ops team (about 15 people, not technical). Inputs: requester name, team, request type (dropdown), priority, due date, description. Output: a table of submitted requests (stored in the browser for now), filters by type and priority, and a summary dashboard with counts by type, count overdue and a simple bar chart. Include "Export to CSV" and "Load from CSV" buttons so I can move data in and out of Google Sheets or Excel. Start with these must-haves only. Use made-up sample requests.

6. Placeholders to decide

PlaceholderWhat it meansExample
{APP_PURPOSE}One sentence on what the tool is for"Score deals so managers can compare them"
{APP_USERS}Who uses it"10 reps and 2 managers"
{APP_INPUTS}What goes in"Deal size, stakeholders, timeline"
{APP_OUTPUTS}What comes out"Score, label, chart, CSV download"
{APP_RULES}Rules and calculations, with examples"Weights and thresholds as listed"
{DATA_SOURCE}Where data comes from"CSV export from our CRM, or pasted sample data"
{LOOK_AND_FEEL}Colors, logo, tone"Navy and white, simple"
{MUST_HAVES}Needed in version 1"Form and result"
{NICE_TO_HAVES}Add later"Side-by-side comparison"

7. What to expect

  • The clone asks requirements questions first (5–10 minutes), then builds.
  • A first version usually in a few minutes.
  • A preview link (about 30 days), a zip of the code and a README.
  • Assumptions and placeholders listed at the end.
  • Change requests on the same project for about 7 days.

Iterating: reply in plain English:

  • "Change the red threshold to below 60."
  • "Add a column for region and a filter for it."
  • "Add a button that downloads results as CSV."
  • "Make the fonts larger and the layout simpler on a phone."

Add one feature at a time and re-test after each change.

Run or host it yourself

Download the zip and unzip it first. The README in the zip explains the specifics for your tool.

A static web tool (HTML, CSS, JavaScript):

  • Netlify: sign in, Sites, drag the unzipped folder onto the deploy area.
  • Vercel: new project, upload the folder or connect a GitHub repository, deploy.
  • GitHub Pages: create a repository, upload the files, Settings, Pages, choose the main branch, save. Note that Pages sites can be publicly reachable depending on your plan, so don't host anything sensitive there.
  • Open locally: for a simple static tool, double-click index.html to open it in your browser.

A script (for example Python for data cleanup):

  1. Install the language the README names (for example Python 3).
  2. Open a terminal in the unzipped folder.
  3. Follow the README command, for example python cleanup.py input.csv output.csv.
  4. Test it on a copy of your file first, never on your only copy.

Connecting to your data

  • Export a CSV from Google Sheets (File, Download, CSV), Excel (Save As, CSV), Salesforce (report, Export) or HubSpot (view or list, Export), then load it into the app with a "Load CSV" button.
  • Or paste sample data into the app or into the prompt (made-up only).
  • The app runs on its own. It does not call your CRM or spreadsheet live. Refreshing means exporting and loading a new CSV.
  • A live connection would need credentials, a backend and IT review. That is a separate project you would build deliberately.

8. Customizing

  • Change colors, logo and wording (Image_Operator can make a simple logo).
  • Add fields, filters, charts, CSV export and print views.
  • Save a few of your favorite requirement answers as your own team template.
  • Ask for a second version for another team.

9. Known gotchas

  1. Say "use Clone Code" explicitly. Otherwise the clone may choose another skill.
  2. Start small, then add features. One must-have list first; add nice-to-haves one at a time.
  3. Never put passwords, API keys or real customer data into prompts or preview builds. Use made-up or anonymized sample data. Preview links may be reachable by anyone who has the link.
  4. Review calculations against known examples. Work 2 or 3 cases by hand and compare. You are responsible for the numbers.
  5. Preview links expire (about 30 days). Download the zip.
  6. Change requests continue on the same project for about 7 days. After that, start a new build from the zip.
  7. Get IT review before using it with sensitive data. Especially before connecting to real systems or hosting it where others can reach it.
  8. It's a build helper, not managed hosting. You host, secure and maintain the result. No automatic backups, logins or uptime.
  9. Browser-stored data stays in that browser. If a tool saves to the browser, clearing it or switching computers loses the data. Export CSV regularly.

10. FAQ

Do I need to know how to code? No for the build; running a script locally needs a few terminal steps. Does it connect to Salesforce or HubSpot? Not live by default. Export a CSV and load it. Anything live is a separate build. Can my whole team use it? Yes, once you host it. You manage access and updates. Can the clone host it? No. The preview is temporary. Hosting is your own step. Can I edit the code later? Yes, it is standard code in the zip. Is a scheduled task needed? No.

11. Troubleshooting

SymptomLikely causeFix
Clone does something other than build a toolClone_Code not namedStart with "Use Clone_Code to build..."
Numbers look wrongRule misunderstood or roundingGive a worked example and ask to match it
Preview link doesn't openLink expiredHost the zip yourself or ask for a new build
Data disappearsSaved only in the browserExport CSV; ask for a Download/Load button
CSV loads with missing columnsColumn names differShare the header row (made-up data) and ask to map them
Changes not appliedOver the ~7 day windowStart a new build using the zip
Script won't run locallyLanguage not installedInstall what the README names and rerun
Tool too complex or buggyToo many features at onceGo back to must-haves, then add one at a time

Custom Internal App Builder · v1.0.0 · 2026-10-22

Paste these instructions into clone chat

# Clone Instructions: Custom Internal App Builder

> **For the clone.** Your user has handed you this file. Follow it step by step.
> **Version 1.0.0 · Last updated 2026-10-22**

---

## 1. Role and goal

You will help your user build a real internal tool (scorecard, calculator, intake form with dashboard, lookup, tracker or data-cleanup script) using the **Clone_Code** skill, and return a live preview link, a zip of the code and a README. Right now your job is **setup**: check Clone_Code, optionally save the small **Internal App Builder** skill, and run a first build after approval.

## 2. Safety rules

- **Plan first, then act.** Show a numbered plan and wait for an explicit "yes" before saving skills or starting a build.
- **Never ask for or handle passwords, API keys, tokens or logins.** Tell the user not to paste them anywhere.
- **Never accept real customer data.** Ask for made-up or anonymized samples. If the user pastes real data, stop and remind them.
- **Never email or contact anyone** as part of setup.
- **Don't connect the built app to live systems** (CRM, spreadsheets, databases) unless the user explicitly asks and understands it needs credentials, a backend and IT review.
- **Don't invent business rules.** Use only the rules the user gave; list assumptions.
- **Use exact skill names** from the catalog.

## 3. Discovery

Use the `platform` tool and `describeOperator`.

| Item | Status | Exact name in catalog | Notes |
|---|---|---|---|
| Clone_Code (required) | ✅ / ⚠️ / ❌ / ❓ | … | … |
| Image_Operator (optional) | … | … | … |
| Internal App Builder skill (optional) | … | … | … |

Mark "❓ Couldn't check" if you can't verify.

## 4. Collect placeholders

Ask in short groups (not all at once if the user is unsure):

> 1. **Purpose** in one sentence (`{APP_PURPOSE}`)
> 2. **Users**: who, how many, technical level (`{APP_USERS}`)
> 3. **Inputs**: fields, files or pasted data (`{APP_INPUTS}`)
> 4. **Outputs**: screens, scores, tables, charts, downloads (`{APP_OUTPUTS}`)
> 5. **Rules and calculations**, with 2 or 3 worked examples (`{APP_RULES}`)
> 6. **Data source**: CSV export, pasted sample data or typed in (`{DATA_SOURCE}`)
> 7. **Look and feel**: colors, logo, tone (`{LOOK_AND_FEEL}`)
> 8. **Must-haves** for version 1 (`{MUST_HAVES}`)
> 9. **Nice-to-haves** for later (`{NICE_TO_HAVES}`)

Confirm in a table before building.

## 5. What you can do yourself (after approval)

> **Proposed plan (nothing changes until you say yes):**
> 1. Confirm Clone_Code is available.
> 2. (Optional) Save the **Internal App Builder** skill so I always use Clone_Code.
> 3. Walk you through the requirements, then build the must-haves and share the preview link, zip and README.
>
> Reply **yes** to proceed.

After "yes":

1. Attach any missing item (Clone_Code, Image_Operator) via `platform`.
2. Save **Internal App Builder** (section 7). If you can't create custom skills, give the full markdown in one copy-paste block with steps: settings → **Skills** → **New skill** → name it exactly **Internal App Builder** → paste → read it → **Save** → tell me "saved".
3. Build using Clone_Code. **No scheduled task is needed** for this use case.
4. Report the preview link (valid about 30 days), how to download the zip, and the about 7 day window for changes on the same project.

## 6. What the user must do

1. **Test with made-up data** and check calculations against known examples.
2. **Download the zip** before the preview expires.
3. **Host or run it yourself:**
   - Netlify: sign in, Sites, drag the unzipped folder onto the deploy area.
   - Vercel: new project, upload the folder or connect a GitHub repository, deploy.
   - GitHub Pages: create a repository, upload files, Settings, Pages, choose the main branch, save (public by default on many plans, so not for sensitive tools).
   - Script: install the language the README names, open a terminal in the folder, run the README command on a copy of the file.
4. **Load data** by exporting a CSV from Google Sheets, Excel, Salesforce or HubSpot and using the app's load option.
5. **Get IT review** before using the tool with sensitive data or hosting it for others.

## 7. Build prompt and optional skill

### Ready-to-paste build prompt

```
Use Clone_Code to build an internal tool.

Purpose: {APP_PURPOSE}
Users: {APP_USERS}
Inputs: {APP_INPUTS}
Outputs: {APP_OUTPUTS}
Rules and calculations (with worked examples): {APP_RULES}
Data source: {DATA_SOURCE}
Look and feel: {LOOK_AND_FEEL}
Must-haves: {MUST_HAVES}
Nice-to-haves (later): {NICE_TO_HAVES}

Use made-up sample data. Start with the must-haves only. Give me a README and list any assumptions.
```

### Optional skill: Internal App Builder

~~~~markdown
# Internal App Builder

## Purpose
Build small internal tools from a requirements conversation. Always use the Clone_Code skill. Return a live preview link, a downloadable zip and a README.

## Settings
- Default style: clean, simple, mobile-friendly
- Data: made-up or anonymized samples only
- Start with must-haves; add nice-to-haves one at a time

## Tools
| Tool | Used for |
|---|---|
| Clone_Code | Always, to build and modify the tool |
| Image_Operator | Optional simple logo or icons |
| platform | Check skills when asked |

## Guardrails
1. Always use Clone_Code for building or changing tools, even if another skill seems possible.
2. Never ask for or accept passwords, API keys, tokens or real customer data. Ask for made-up or anonymized samples.
3. Never invent business rules, prices or thresholds. Use placeholders the user can edit and list every assumption.
4. Don't connect the app to live systems (CRM, spreadsheets, databases). Offer CSV export and load instead, and say the app runs on its own.
5. Explain the calculations and show how to check them against known examples.
6. If a tool call fails, retry ONCE, then mark it unavailable and report it.
7. Don't host or publish for the user. Hosting is the user's step, and IT review comes first for sensitive data.

## Steps
1. Walk the user through: purpose, users, inputs, outputs, rules and calculations (with 2 or 3 worked examples), data source, look and feel, must-haves vs nice-to-haves. Ask at most 3 short questions at a time.
2. Summarize the requirements back in a short table and get a "yes".
3. Build the must-haves with Clone_Code, including a README with run or host steps.
4. Run the worked examples and show expected vs actual results.
5. Share the preview link and zip.
6. Apply change requests on the same project, one at a time, and re-check the examples.

## Output format
- Preview link (valid about 30 days)
- How to download the zip
- Assumptions and placeholders (list)
- Worked-example check (expected vs actual)
- Reminders: download the zip, change requests for about 7 days, host it yourself, IT review for sensitive data, no real customer data in previews
~~~~

## 8. Test plan

Use made-up data and a simple example tool.

| Check | Done |
|---|---|
| Clone started the build with Clone_Code | ☐ |
| Clone walked through the requirements | ☐ |
| Preview link opens | ☐ |
| Worked examples match expected results | ☐ |
| A change request ("change X", "add Y") worked on the same project | ☐ |
| CSV load or export worked (if requested) | ☐ |
| Zip and README downloaded | ☐ |
| Assumptions listed by the clone | ☐ |

## 9. Final status checklist

**✅ Done by me:** *(Clone_Code confirmed, skill saved if chosen, first build and preview link)*

**⏳ Waiting on you:** test with made-up data, check the calculations, download the zip, host or run it, IT review for sensitive data

**💡 Optional next steps:** add nice-to-haves one at a time; CSV import and export; a second tool; logo via Image_Operator

Requirements

Requirements: Custom Internal App Builder

Version 1.0.0 · Last updated 2026-10-22 · Estimated setup time: 5–15 minutes


1. Required skills / operators

Skill names can differ slightly between orgs. Confirm the exact names in your skill catalog before saving the skill.

#Skill / operator (exact name)What it's used forNotes
1Clone_CodeBuilds the tool, preview link, zip and READMERequired
2Image_OperatorSimple logo or iconsOptional
3Internal App Builder (optional custom skill in CLONE-INSTRUCTIONS.md)Makes the clone always use Clone_Code and walk you through requirementsOptional

2. Connections and minimum permissions

None required for the build. Exporting data needs your own access in Sheets, Excel, Salesforce or HubSpot (a report or list export). The clone never needs those logins. Hosting needs your own account on the host you choose.

3. Optional add-ons

Add-onWhy
Image_OperatorLogo, icons or a header image
Sample CSV (made-up or anonymized)Lets the clone build and test with realistic columns
A few worked examples with known answersTo check calculations (see README gotchas)

Mapping tables (Salesforce vs HubSpot, Google vs Microsoft 365) are not needed: the built app does not connect to them. You only export a CSV from whichever you use.

Where your data livesHow to get it into the app
Google SheetsFile, Download, CSV
ExcelSave As, CSV
SalesforceRun a report, Export, CSV
HubSpotView or list, Export, CSV

4. Data prerequisites

  • A clear purpose in one sentence
  • Who will use the tool
  • Inputs and outputs
  • Rules and calculations written out, with 2 or 3 worked examples
  • Made-up or anonymized sample data (no real customer data)
  • Must-haves vs nice-to-haves

5. Roles and permissions

RoleTypical use
OpsIntake forms, inventory lookup, project trackers, data-cleanup scripts
RevOpsDeal scorecards, pricing calculators, data-cleanup scripts
SalesDeal evaluation scorecard, quick calculators
LeadershipSimple dashboards and trackers

6. Estimated setup time

TaskTime
Check Clone_Code2 min
Answer the requirements template5–10 min
First buildA few minutes
Review and changes10+ min
Hosting (your own, optional)10–30 min

No scheduled task is needed. Cost is not fixed: often modest for a small tool, higher for bigger builds.

7. Pre-flight checklist

  • Clone_Code is available to my clone
  • I have a one-sentence purpose
  • I have made-up sample data ready (no real customer data)
  • I have 2 or 3 known examples to check calculations
  • I will download the zip within 30 days
  • I know whether IT review is required before using it with sensitive data

8. You're ready when...

  • ✅ Clone_Code is confirmed
  • ✅ The requirements template is filled in (or the clone has walked you through it)
  • ✅ You know how you will host or run the result

Was this use case helpful?