# Scult Tools

> Free tools that do the boring work for you

Free online tools plus a verified AI prompt library — SEO, business, developer and design utilities, and copy-paste prompts for ChatGPT, Claude, Cursor, Midjourney and more. Built by Scult, an AI-first digital agency. 13 of 15 tools run entirely in your browser. No signup on any of them. Full policy: https://tools.scult.in/privacy

## Tools

### SEO

#### Schema Markup Generator (JSON-LD)
URL: https://tools.scult.in/seo/schema-markup-generator
Fill a form, get paste-ready JSON-LD — with Google’s requirements checked as you type.

How it works: JSON-LD is the script-block format Google recommends over microdata. This tool builds it from a typed spec table so each schema type nests properties correctly (an Article author becomes a Person, a Product price sits inside an Offer), flagging fields Google rich results require, not just schema.org optional ones.

Limitations: Valid markup makes a page eligible for a rich result — it does not guarantee Google shows one. Markup must match what users actually see on the page, or it risks a manual action. Covers the nine most-used types; niche types like Recipe or JobPosting have extra requirements.

#### FAQ Schema Generator
URL: https://tools.scult.in/seo/faq-schema-generator
Q&A in, valid FAQPage JSON-LD out — with the visible HTML Google requires.

How it works: Your pairs become a schema.org FAQPage: a mainEntity array of Question objects whose acceptedAnswer holds the Answer text — the shape Google’s structured-data docs specify. Every "<" is serialised as \u003c, so embedded HTML can’t break out of the <script type="application/ld+json"> tag. Google retired FAQ rich results on 7 May 2026, but AI answer engines still parse this markup, and the HTML output satisfies the on-page-visibility requirement schema.org checks require.

Limitations: FAQ rich results were retired by Google on 7 May 2026, so this markup won’t produce an expandable Q&A in search — it’s worth adding for AI answer engines and schema clarity instead. The marked-up questions and answers must also be visible as real text on the page; schema with no matching on-page content violates Google’s guidelines. The ~1,200-character answer limit the tool flags is a holdover from the retired rich result, kept as a discipline for concise, quotable answers rather than an enforced rule.

#### UTM Campaign URL Builder
URL: https://tools.scult.in/seo/utm-builder
Tag campaigns consistently, so your reports are readable.

How it works: Parameters are appended via the URL API, so it works correctly even if the destination already has a query string or fragment. Values are lowercased and spaces become hyphens, since GA4 treats `Spring-Sale` and `spring-sale` as separate campaigns — a common cause of fragmented reports.

Limitations: UTMs are visible in the URL and editable by anyone — never use them for access control or secrets. GA4 also auto-reads `gclid` and `fbclid`, so adding UTMs on top of auto-tagged ads can double-count.

#### Marketing ROI Calculator
URL: https://tools.scult.in/seo/marketing-roi-calculator
ROI and ROAS side by side, with margin — so the real number shows.

How it works: ROI = (revenue × margin − spend − other costs) ÷ (spend + other costs) × 100; ROAS = revenue ÷ spend. ROAS credits every rupee as profit, while ROI keeps only margin and charges all costs, so break-even ROAS = 1 ÷ margin — a "good" 3× ROAS at 25% margin can still be a loss.

Limitations: Last-click credit: revenue attributed here gets full credit, so summing across a multi-touch journey overstates total ROI. No incrementality or LTV adjustment: some of this revenue would have happened anyway, and repeat purchases are not counted.

#### Website Speed Test
URL: https://tools.scult.in/seo/website-speed-test
One score, real thresholds, and the fixes that actually matter.

How it works: Runs Google’s own Lighthouse engine via the free PageSpeed Insights v5 API — the same test behind pagespeed.web.dev. It reports lab data (one simulated Chrome load) and field data (CrUX: real users at the 75th percentile). Each Core Web Vital is scored against Google’s published Good/Poor thresholds; it also surfaces server response time (TTFB), the third-party scripts costing the most main-thread time, and a transfer-size breakdown by resource type. Retests of the same URL are cached for 6 hours.

Limitations: A lab score is one run from one Google data centre, so a few points of swing between runs is normal — treat trends as meaningful, single runs as indicative. Field (CrUX) data only exists when a page gets enough Chrome traffic; smaller pages may fall back to origin-wide data or none at all.

### Business

#### Free Invoice Generator
URL: https://tools.scult.in/business/invoice-generator
A professional invoice, made in your browser — printed to PDF, uploaded nowhere.

How it works: Amounts are computed in integer minor units, not floating-point: each line total is rounded once, and discount and tax are rounded once more, so subtotal minus discount plus tax reconciles exactly. Discount applies before tax, matching GST/VAT rules. Export is your browser’s Print to PDF; nothing is uploaded.

Limitations: It generates a standard invoice document, not a GST e-invoice — no IRN or signed QR code from the government portal. It has no client database or invoice ledger beyond the single autosaved draft in your browser.

#### Business Name Generator
URL: https://tools.scult.in/business/business-name-generator
Five naming strategies, with the method shown — not hidden.

How it works: Names are built combinatorially in your browser, not by an AI call — five strategies (brandable syllables, compound words, modern suffixes, portmanteau, alliteration) generate candidates, then each is scored for length against an eight-letters-or-fewer sweet spot and for pronounceability via a consonant-cluster heuristic flagging three-plus consonants in a row.

Limitations: No trademark or company-registry search is performed — verify a name against the Indian trademark registry and MCA database before committing to it. Domain availability isn’t checked; “Check domain” just opens Namecheap’s public search in a new tab.

#### Slogan Generator — Free Tagline Maker
URL: https://tools.scult.in/business/slogan-generator
Ten taglines per click, in the tone your brand actually speaks.

How it works: Each tone draws on a hand-written bank of 16-plus sentence patterns — benefit-led, contrast, imperative. Your keyword is inflected grammatically: capitalised at a sentence start, a/an chosen by vowel sound. Batches shuffle the bank, excluding lines already shown, so regenerating never repeats. No LLM.

Limitations: Templates don’t know your positioning or audience — treat lines as raw material, not finished copy. Nothing here is trademark-checked, so search before using a line anywhere permanent.

#### Email Signature Generator
URL: https://tools.scult.in/business/email-signature-generator
Signatures built from HTML that survives Outlook.

How it works: Desktop Outlook renders with Microsoft Word’s engine, which ignores flexbox and grid; Gmail strips <style> blocks. So this generator writes nested-table markup with every style inline — the format both render faithfully. It copies to your clipboard as a text/html ClipboardItem, so pasting keeps formatting, not raw code.

Limitations: Photo and logo URLs must already be publicly hosted — this tool does not upload or store images. Many clients block remote images by default, so recipients may not see your photo until they choose to load it.

### Developer

#### JSON Formatter & Validator
URL: https://tools.scult.in/dev/json-formatter
Format and validate JSON without sending it anywhere.

How it works: Parsing uses the native JSON.parse, the fastest and most standards-accurate option available. Its errors only give a character offset, so we convert that into a line and column and show the offending line — turning "unexpected token at position 1043" into "trailing comma on line 42."

Limitations: Strict JSON only — comments, trailing commas and single-quoted strings are reported as errors, not silently fixed. Integers beyond 2^53 lose precision; JavaScript numbers are IEEE-754 doubles.

#### QR Code Generator (with UPI)
URL: https://tools.scult.in/dev/qr-code-generator
Generate a permanent QR code — no redirect, no tracking, no expiry.

How it works: QR generation happens entirely in your browser, so the code encodes your data directly rather than a tracking redirect on our domain — unlike most free generators, it keeps working even if we go away or start charging. UPI codes follow the NPCI deep-link spec: `upi://pay?pa=<vpa>&pn=<name>&am=<amount>&cu=INR`.

Limitations: The code can't be edited after printing and there's no scan analytics — that's the trade-off for permanence. Very long inputs need a denser matrix, which needs a larger printed size to stay scannable.

#### Favicon Generator
URL: https://tools.scult.in/dev/favicon-generator
Create perfect favicons for all platforms in seconds.

How it works: Your source is drawn onto a 512px canvas, then scaled to each target size with high-quality resampling. The favicon.ico is byte-assembled here as a real ICO container packing PNGs for 16, 32 and 48px, valid since Windows Vista. The apple-touch-icon is flattened onto a solid background because iOS ignores alpha. Nothing leaves your browser.

Limitations: No SVG output — that needs real vector source art, not a rasterised wrapper. Detailed photos and busy logos turn to mud at 16px; simplify the source if the preview looks smudged. Emoji artwork comes from your device’s fonts, so it can look different on other platforms.

### Productivity

#### Word Counter — Words, Characters & Reading Time
URL: https://tools.scult.in/productivity/word-counter
Live word, character and reading-time counts that never leave your browser.

How it works: Words and characters are segmented with Intl.Segmenter (Unicode UAX #29), counting grapheme clusters rather than UTF-16 units, so contractions and space-free scripts like Chinese count correctly. Reading time uses 238 words/minute (Brysbaert, 2019); speaking time uses 130 wpm. Runs locally in your browser.

Limitations: Reading time (238 wpm) is a population average — technical or unfamiliar text reads slower, skimming faster. Keyword density is a diagnostic, not an SEO target — writing to a percentage is keyword stuffing. The X character badge is a close approximation: X itself counts URLs as 23 characters and weights some scripts as two. The stopword list is English-only, so density for other languages will include function words.

### Design

#### Colour Palette Generator
URL: https://tools.scult.in/design/color-palette-generator
One colour in, a usable palette out — checked for contrast.

How it works: Harmonies are computed in OKLCH, not HSL: HSL lightness does not match perceived lightness, so HSL yellow and blue at the same value differ by roughly 4x in actual luminance, producing lumpy palettes. OKLCH is perceptually uniform, so holding lightness constant looks even across hues, and the ten-step ramp stays evenly spaced.

Limitations: Very saturated inputs may shift slightly, since out-of-gamut OKLCH colours get clamped to sRGB. A generated palette is a starting point, not a brand — it carries no meaning of its own.

### GEO / AEO

#### AI Visibility Checker
URL: https://tools.scult.in/geo/ai-visibility-checker
See your website the way AI search engines see it.

How it works: Fetches robots.txt, /llms.txt and your homepage once, then applies robots precedence for ten AI crawlers: most-specific User-agent group wins, longest matching path wins. Scored 40/20/20/10/10 across crawler access, structured data (including whether it names an Organization/WebSite/LocalBusiness/Person), page basics (title, description, headings, lang, Open Graph tags, canonical link, image alt-text coverage and a thin-content check), llms.txt and sitemap — being readable is necessary, not sufficient, for citation. A separate, unscored check flags a noindex or nofollow homepage, since that alone can make every other signal moot.

Limitations: This checks your homepage only, not every page on your site. It reports the public crawl signals it can see, not what an AI company does with your content afterward. It reads the HTML your server sends, not the DOM after JavaScript runs — a single-page app that injects its title, meta description or schema client-side will score lower here than a real visitor would experience.

## Guides

### How to Make Your Website Visible to AI Search — A Practical Checklist
URL: https://tools.scult.in/guides/ai-search-visibility-checklist
AI answer engines can only cite a page they can crawl, understand and quote. This is the checklist that decides whether yours is one of them — the same one our AI Visibility Checker scores automatically.

**Why this is worth doing now**
ChatGPT, Perplexity and Google’s AI Overviews increasingly answer a question directly, without sending anyone to the page the answer came from. That changes the incentive: ranking well in classic search no longer guarantees anything if the engine quoting an answer never considered the page citable in the first place.
What makes a page citable is checkable, not mysterious. Can the AI crawler actually fetch it, does it declare what it is through structured data, do the on-page basics give an engine something worth quoting, and is there a machine-readable map of what pages exist. This checklist covers exactly those things, in the order they matter.

**Do not block the AI crawlers in robots.txt**
A robots.txt rule that blocks an AI crawler — by name or through a wildcard group — is the single biggest reason a site never shows up in an AI answer, because every other check on this list is irrelevant if the crawler cannot fetch the page at all. Ten crawlers are worth checking by name: GPTBot (OpenAI, model training), OAI-SearchBot (OpenAI, ChatGPT search index), ChatGPT-User (OpenAI, live ChatGPT browsing), ClaudeBot (Anthropic, model training), anthropic-ai (Anthropic, legacy Anthropic crawler), PerplexityBot (Perplexity, Perplexity search index), Google-Extended (Google, Gemini training and grounding), CCBot (Common Crawl, the open dataset many models train on), Bytespider (ByteDance, model training), and meta-externalagent (Meta, Llama training).
The rule that decides each one is the most specific User-agent group that names it, falling back to a wildcard User-agent: * group only when nothing more specific matches. Within a group, the longest matching path wins regardless of where it sits in the file, and an exact tie between an Allow and a Disallow goes to Allow. A bare Disallow: with nothing after the colon blocks nothing — it is a common way to write "allow everything" by accident. And if robots.txt has no group for a bot at all, or the file is missing entirely, that bot is allowed by default, the same as it always has been for ordinary search crawlers.

**Publish an llms.txt**
llms.txt is a plain markdown file at the root of a site — /llms.txt — listing the most important pages with a one-line summary each. It gives an AI system a curated map instead of forcing it to infer what matters from a full crawl. It is an emerging standard, not yet something every site has, which is exactly why it is worth doing early: most competitors will not have one yet, so it is a real point of difference rather than table stakes. Writing one takes about ten minutes and needs no build tooling — a static file served at the root is enough.

**Add structured data that says what your site is**
At minimum, one JSON-LD script block on the homepage declaring an Organization or WebSite type — LocalBusiness or Person also count, for a site that identifies as a business with a physical presence or an individual. With none of these, an AI system has to infer what the site even is from prose alone. And having some structured data is not automatically enough: a page can carry FAQPage or Article schema and still leave the basic question unanswered, because those describe what one page is about, not what the site behind it is.
Adding a single <script type="application/ld+json"> tag with at least one of those four identity types is the cheapest structured-data fix available, and it should come before adding anything more specific to individual pages.

**Get the on-page basics right**
These are the plain signals an AI system reads before doing anything clever: a <title> tag, a meta description, exactly one h1, at least two real h2 section headings, a lang attribute on the <html> tag, a complete Open Graph trio (og:title, og:description, og:image), a <link rel="canonical"> tag, alt text on at least 80% of the page’s images, and enough visible text to be worth citing — the working threshold is 150 words, because a homepage shorter than that gives an engine nothing to quote no matter how many other boxes it ticks.
None of this is exotic. It is the same on-page hygiene classic SEO has asked for for years, which is worth noting on its own: a site that already does ordinary SEO well is most of the way to AI visibility already. These nine signals are best treated as a set — missing one or two is a minor gap, missing most of them is a real problem.

**Declare your sitemap in robots.txt**
An XML sitemap lets a crawler discover every page on a site without following links one at a time. Simply having the file at /sitemap.xml is only half of it: a crawler checking for a sitemap looks first for a Sitemap: line inside robots.txt, and typically only tries the conventional /sitemap.xml path directly as a fallback when robots.txt does not mention one. Add a line like "Sitemap: https://yourdomain.com/sitemap.xml" to robots.txt so every crawler finds it the same way, instead of relying on each one to guess correctly.

**Check for an accidental noindex**
A noindex directive in the meta robots tag or the X-Robots-Tag response header tells every search and AI engine not to index the page at all. It is not one signal among many — it overrides everything above it, because none of the rest of this checklist matters if the homepage itself is told not to be indexed. It happens by accident more often than seems likely: a staging flag left on after launch, a theme or plugin default nobody reviewed before going live. A nofollow directive is milder — the page can still be indexed, but its outgoing links stop passing discovery to the rest of the site — and is worth clearing too unless it is deliberate.

**Checking where a site actually stands**
Working through this by hand means opening robots.txt, viewing page source, and checking each of the ten crawlers above one at a time. Our AI Visibility Checker runs the whole checklist automatically: paste in a URL and it evaluates crawler access bot by bot, structured data, the nine on-page basics, llms.txt, the sitemap declaration, and the noindex and noai signals, then returns a 0–100 score with the specific robots.txt line or missing tag behind every result.

### JSON-LD Structured Data, Explained Simply
URL: https://tools.scult.in/guides/json-ld-structured-data-basics
JSON-LD is the script block that tells search engines and AI crawlers what a page actually is, without changing what a visitor sees. Here is what it covers, which schema types matter, and the one rule that gets FAQ markup penalized.

**What JSON-LD actually is**
JSON-LD is a small script block added to a page’s HTML. It describes the page in a structured, machine-readable way — this is an Article by this author, this is a Product at this price, this is an Organization with this name and logo — using vocabulary from schema.org. It sits alongside the visible HTML, not instead of it: a browser ignores it, but search engines and AI crawlers read it to work out what the page is actually about, rather than inferring it from headings and layout.
Google recommends JSON-LD over the older microdata format because it is one self-contained <script type="application/ld+json"> tag rather than attributes woven through your existing markup. That makes it easier to generate, template and update without risking the page’s actual display.

**The schema types worth knowing**
A handful of schema.org types cover most of what a small business site needs. Organization describes the company itself — name, URL, logo, contact details — and usually belongs on every page rather than just one. WebSite tells search engines the name and URL of the site as a whole, which is part of what can produce a sitelinks search box for a brand in results.
Product describes a specific item for sale — price, availability, reviews — and is what can put a price or star rating under a search result. Article covers a blog post or news piece: headline, author, publish date. FAQPage marks up a list of questions and their answers as Q&A pairs a machine can read directly, rather than one block of prose.
BreadcrumbList describes the click path to a page — Home, then a category, then the page itself — which is what can turn a URL in search results into a breadcrumb trail instead. LocalBusiness is Organization’s more specific sibling: it adds an address, opening hours and a phone number, and matters most for a business with a physical location or a defined service area.

**How to check it actually works**
Two tools cover most of what validation requires. Google’s Rich Results Test checks whether a page’s markup is eligible for one of Google’s specific rich result types — useful for spotting a Product or Article block missing a property Google requires — though it dropped FAQPage support in June 2026 along with FAQ rich results generally. The generic schema.org validator checks markup against the schema.org vocabulary itself, so it is the one to reach for on FAQPage or anything else Google’s tool no longer covers, or simply to confirm the JSON parses and nests correctly.
Passing either check only confirms eligibility, not that a rich result will appear. Google also weighs page quality, whether the markup matches what a visitor actually sees, and per-query relevance — and a rich result can take days or weeks to show up even on markup that validates cleanly. Structured data is not itself a ranking factor; it makes a page eligible for a better-looking result and helps machines disambiguate what the page covers.

**The rule that gets FAQPage schema penalized**
One rule matters more than any other with FAQPage markup: the questions and answers in the JSON-LD have to appear on the page as real, visible text — the same words, not a paraphrase, and not hidden with no visible fallback. Schema with no matching on-page content violates Google’s guidelines, and that is treated as a manual-action risk, not a technicality to skip.
This trips people up because it is easy to hand-write a tidy FAQPage block and forget to also put that exact copy on the page. If a page does not already show the FAQ text, the safer path is to generate the visible HTML and the schema together rather than the JSON-LD alone.

**A minimal example: Organization markup**
A basic Organization block is short. Conceptually it holds three things: the company’s name as a plain string, a url pointing at the homepage, and a logo pointing at an image URL. Everything else — sameAs links to social profiles, a contactPoint, a full address — sits on top of that minimum; it is additive, not required to make the block valid.

**Generating it without hand-writing JSON**
Hand-writing JSON-LD is where small syntax mistakes creep in — a missing comma, a string where a nested object belongs. The schema markup generator builds it from a typed spec table instead, covering nine schema types and flagging whatever Google’s rich results actually require as the fields are filled in.
For questions and answers specifically, the FAQ schema generator does the same thing and also outputs the paste-ready visible HTML block, so the visibility rule above is satisfied by construction rather than by remembering to do it by hand.

### What Every Invoice Needs — A Guide for Indian Freelancers and Small Businesses
URL: https://tools.scult.in/guides/invoice-essentials-for-indian-freelancers
Most late payments trace back to the invoice, not the client. Missing due dates, numbering that skips, totals that do not add up — this is what a complete invoice actually needs, and where India-specific rules come in.

**The fields every invoice needs, anywhere in the world**
Before any country-specific rule applies, an invoice is a document that has to answer a few plain questions: who billed whom, for what, how much, and by when is it due. Leave one of those out and you have not sent an invoice — you have sent an itemized guess.
A complete invoice needs: a unique invoice number, the issue date, and a due date. Your business details and your client’s — name, address and a way to reach each of you. Itemized line items, each with a description, quantity and rate, rather than a single lump sum. A subtotal, the tax applied (if any) and the total. And a stated payment term and method — how many days the client has to pay, and where the money should actually go.
None of these fields is decorative. The invoice number and issue date are what make the document referenceable later, in an email thread or an accounting system. The line items are what let a client’s finance team check your math instead of taking your total on faith. And the payment terms are what turn "please pay" into something with an actual deadline attached.

**The India-specific basics: GSTIN, CGST/SGST vs IGST, and numbering**
If you are registered for GST, show your GSTIN on the invoice, in your business’s address block. A client who is also GST-registered will often need it to claim input tax credit, and its absence is a common reason an invoice bounces back for correction.
The tax split depends on where you and your client are located, not on what you sell. Bill a client in the same state as your registered place of business, and the tax is split into CGST and SGST. Bill a client in a different state (an inter-state supply), and the tax is charged as IGST instead. This is a genuinely common source of invoicing mistakes, because the total tax rate is often the same either way — only the split changes, and getting the split wrong is still wrong.
Keep your invoice numbering sequential, without gaps or repeats, across your entire billing history — not per client or per month in isolation. A number that skips, or two invoices sharing the same number, is one of the first things a client’s accounts team or a GST officer will flag.
None of the above is tax advice, and it is deliberately kept generic. GST treatment has exceptions, thresholds and edge cases (composition scheme, exports, reverse charge, and more) that depend on your specific registration and the nature of what you are billing. If a GST detail actually matters for a given invoice, confirm it with a chartered accountant before you rely on it.

**Billing clients outside India**
An international client does not need a GST split. What they do need is the invoice in a currency they recognize, with a total that does not need converting by hand before it can be approved for payment.
This is the one place where the right tool matters more than the rule: our Invoice Generator supports eight currencies, so an invoice for a client in the US, the UK, the EU or elsewhere can be issued in their currency directly, with every line item and total already computed in it, rather than in rupees with a currency symbol relabeled afterward.

**Mistakes that get invoices rejected or paid late**
A large share of "late" payments are actually invoices that were never payable on time in the first place, because something on the document made the client’s finance team stop and ask a question instead of just paying it. The recurring offenders:
No due date, or a due date implied rather than stated. "Payment appreciated promptly" is not a due date. Every invoice needs an explicit date, and it should follow from a stated payment term (Net 7, Net 15, Net 30) rather than being picked at random.
No payment terms or payment method. A total with nowhere to send it — no bank details, no payment link, no method at all — sits in someone’s inbox until they think to ask you how to pay.
Inconsistent or reused invoice numbers. Beyond the GST issue above, an accounts team that cannot tell whether an invoice is a duplicate, a correction, or a new bill will often just hold it rather than risk paying twice.
Math that does not reconcile. Line items that do not sum to the stated subtotal, or a tax and total that do not follow from it, is the single fastest way to get an invoice bounced back for correction — and every round trip adds days to when you actually get paid.

**Putting this together**
The fields above are exactly what our Invoice Generator is built around: a live preview as you fill it in, Net 7/14/30 payment terms that fill in the due date for you, and line-item totals computed so the subtotal, tax and total always reconcile. It also lets you carry your GSTIN in the address block for a standard GST tax invoice and continue a sequential invoice series with its Next number field.
Once the invoice looks right, an Email Signature Generator is a small, related finishing touch — it puts your business name, role and contact details into every email you send an invoice from, which is one more way a client can reach you if a question comes up before payment.

## Prompt Library
- [Prompt Library](https://tools.scult.in/prompts): 254 free, dated and version-verified prompts for ChatGPT, Claude, Cursor, Midjourney and more.

### AI Models & Assistants
- [ChatGPT](https://tools.scult.in/prompts/chatgpt): General-purpose ChatGPT prompts that survive model updates. (12 prompts)
- [Claude](https://tools.scult.in/prompts/claude): Prompts built for how Claude actually parses structure. (12 prompts)
- [Claude Code](https://tools.scult.in/prompts/claude-code): CLAUDE.md templates, constraint blocks and review rubrics. (12 prompts)
- [Cursor](https://tools.scult.in/prompts/cursor): .cursorrules files and agent-mode prompts for Cursor. (12 prompts)
- [GitHub Copilot](https://tools.scult.in/prompts/github-copilot): Repository instructions and chat prompts for Copilot. (12 prompts)
- [Gemini](https://tools.scult.in/prompts/gemini): Prompts for Gemini chat, long context and multimodal input. (12 prompts)
- [Perplexity](https://tools.scult.in/prompts/perplexity): Research and source-checking prompts for Perplexity. (12 prompts)
- [AI Companions & Personas](https://tools.scult.in/prompts/ai-companions): Persona-design and role-play scenario prompts for companion apps. (8 prompts)

### Development
- [AI Agents & RAG](https://tools.scult.in/prompts/ai-engineering): Prompts for building agents, RAG pipelines and support bots. (8 prompts)
- [React](https://tools.scult.in/prompts/react): Component, hook and state-management prompts for React. (12 prompts)
- [Next.js](https://tools.scult.in/prompts/nextjs): App Router, caching and rendering-strategy prompts. (12 prompts)
- [Python](https://tools.scult.in/prompts/python): Scripting, data and API prompts for Python work. (12 prompts)
- [Build Apps Without Code](https://tools.scult.in/prompts/no-code-apps): Lovable, Bolt.new, v0 and Replit Agent prompts. (8 prompts)

### Marketing & SEO
- [SEO & GEO/AEO](https://tools.scult.in/prompts/seo-geo): Search optimization prompts for Google and AI answer engines. (18 prompts)
- [Ads & Campaigns](https://tools.scult.in/prompts/ads): Ad copy, campaign briefs and UTM-planning prompts. (8 prompts)
- [Sales & Outreach](https://tools.scult.in/prompts/sales): Cold outreach, follow-up and objection-handling prompts. (12 prompts)
- [LinkedIn](https://tools.scult.in/prompts/linkedin): Post, profile and thought-leadership prompts for LinkedIn. (12 prompts)

### Design
- [Brand & Identity](https://tools.scult.in/prompts/branding): Naming, slogan and visual-identity brief prompts. (8 prompts)
- [Decks & Presentations](https://tools.scult.in/prompts/presentations): Gamma and Canva prompts for decks and visual documents. (8 prompts)

### Business
- [Startup & Strategy](https://tools.scult.in/prompts/startup): Idea validation, pitch and strategy prompts for founders. (12 prompts)
- [Business Ops & Client Comms](https://tools.scult.in/prompts/business-ops): Proposals, invoicing language and client-communication prompts. (8 prompts)

### Content Creation
- [Everyday Writing](https://tools.scult.in/prompts/writing): Emails, resumes and everyday writing prompts. (8 prompts)

### Image Generation
- [Midjourney](https://tools.scult.in/prompts/midjourney): V7-era natural-language and parameter prompts. (2 prompts)
- [Nano Banana](https://tools.scult.in/prompts/nano-banana): Product-photo and editing prompts for Gemini’s image model. (2 prompts)
- [Flux](https://tools.scult.in/prompts/flux): Positive-description prompts for Flux models. (2 prompts)
- [Ideogram](https://tools.scult.in/prompts/ideogram): Text-in-image and typography prompts for Ideogram. (2 prompts)

### Video & Audio
- [Veo](https://tools.scult.in/prompts/veo): Layered video briefs with native audio for Veo. (2 prompts)
- [Kling](https://tools.scult.in/prompts/kling): High-motion and physics-heavy video prompts for Kling. (2 prompts)
- [Runway](https://tools.scult.in/prompts/runway): Reference-driven and character-consistent prompts for Runway. (1 prompt)
- [Music & Voice](https://tools.scult.in/prompts/ai-audio): Suno and ElevenLabs prompts for music and voice design. (3 prompts)

## About this site
- [About](https://tools.scult.in/about): Who builds Scult Tools and why they are free. Built by Scult, an AI-first digital agency in Noida, Delhi NCR — these are the utilities our own delivery team uses.
- [Privacy](https://tools.scult.in/privacy): A plain-English table of exactly which Scult Tools send data over the network and which run entirely in your browser. No accounts, no file uploads, no dark patterns.
- [Terms of Service](https://tools.scult.in/terms): The terms for using Scult Tools: no accounts, you own what you generate, tools are provided as-is, and calculators are aids — not legal, tax or financial advice.
- [Frequently Asked Questions](https://tools.scult.in/faq): Straight answers about Scult Tools: whether it is really free, which tools run in your browser, how AI assistants may use this site, and where to send requests.
- [Contact](https://tools.scult.in/contact): How to reach Scult Tools — report a bug or a wrong calculation, ask about client work, or find us on LinkedIn, Instagram and X.
- [Security](https://tools.scult.in/security): What this site actually does for security: client-side tools that transmit nothing, SSRF-blocked server tools, the real response headers, and how to report a vulnerability.
- [Accessibility](https://tools.scult.in/accessibility): What Scult Tools does for keyboard, screen-reader and low-vision users, the one audit we have not done yet, and how to report an accessibility issue.
- [Changelog](https://tools.scult.in/changelog): What changed on Scult Tools and when — site-wide updates plus a per-tool last-updated list generated straight from the tool registry, not hand-typed.
- [Roadmap](https://tools.scult.in/roadmap): What is live on Scult Tools today, the directions we are weighing next, and how we decide when a tool gets retired instead of left to rot.
- [Brand & Press Kit](https://tools.scult.in/brand): Logos, boilerplate copy and company facts for Scult Tools, for press and partners who want to cite or link to the site correctly.
- [SEO, GEO & AEO Glossary](https://tools.scult.in/glossary): Plain-English definitions of SEO, GEO and AEO terms — AI crawlers, robots.txt, llms.txt, structured data, Core Web Vitals — matched to how our own tools check each one.
- [Tool Collections](https://tools.scult.in/collections): Curated bundles of Scult Tools grouped by what you are actually trying to do — GEO/AEO, SEO, freelance paperwork, developer utilities, and design and writing.
- [Sitemap](https://tools.scult.in/sitemap): A human-readable directory of every page on this site, grouped by section.

## Machine-readable
- [XML sitemap](https://tools.scult.in/sitemap.xml): every URL on the site with a real last-modified date.
- [robots.txt](https://tools.scult.in/robots.txt): explicit allow rules for GPTBot, ClaudeBot, PerplexityBot and the rest of the AI crawler roster.
- [llms.txt](https://tools.scult.in/llms.txt): the same map, link-level only, for a lighter-weight fetch.