AI Agent Skills in Practice: Squirrelscan Audits, OpenClaw Ecosystem, and Custom SKILL.md Workflows
AI is not a threat; it’s a tool, but what a f**ng tool – Anawim, justothepoint.com
Squirrelscan: Website QA for your coding agent
squirrelscan is a command-line website audit tool built for developers and AI coding agents. It crawls a site like a search engine, analyzes every page against 300+ rules across 22 categories, and returns a health score plus concrete, fixable issues. The point is not just to find problems, but to hand your agent enough structure to fix them in your codebase without copy-pasting reports around.
What it audits
The rules span the full surface area of a modern website:
| Category | What it checks |
|---|---|
| SEO | Titles, meta descriptions, canonicals, headings, internal links, structured data |
| Performance | Core Web Vitals, render-blocking resources, page weight |
| Security | HTTPS, security headers, mixed content, leaked secrets (96 patterns) |
| Accessibility | ARIA, button/input names, landmarks, lists, tables, focus |
| Agent experience (AX) | How well the site works for AI agents and crawlers |
| Content & E-E-A-T | Authority, trust, expertise signals |
| And 15+ more | Structured data, crawlability, technical SEO, and others |
The CLI itself is the source of truth: run squirrel with no arguments to see every command and the current rule catalog.
Installation
The skills and local audits both run through the squirrel binary, so install the CLI first:
curl -fsSL https://install.squirrelscan.com | bash
# Verify it is on your `PATH`:
squirrel --version
# Then, check which agent skills are available and whether they are installed:
squirrel skills status
On a fresh machine, the output looks like this:
squirrelscan skills (github.com/squirrelscan/skills @ 29f1776)
skill installed latest where
squirrelscan - 1.23 -
audit-website - 2.9 -
No skills installed: run squirrel skills install.
Auto-update is on: skills update with the CLI.
Install both skills:
squirrel skills install
✓ squirrel auto-updated v0.0.173 → v0.0.176
✓ audit-website 2.9 → ~/.claude/skills, ~/.agents/skills
✓ squirrelscan 1.23 → ~/.claude/skills, ~/.agents/skills
Restart your agent to load them.
The skills land in both ~/.claude/skills (for Claude Code) and ~/.agents/skills (the cross-agent Agent Skills standard). They are the same files, so Cursor, Codex, Gemini CLI, and other compatible agents pick them up from the same location.
The two skills, and why both matter
The install brings in two distinct skills, and they do different jobs:
| Skill | What it does |
|---|---|
squirrelscan |
Operates the CLI: install, login, run audits, publish reports, check credits, manage API keys, set up MCP, and edit configuration. This is the control plane. |
audit-website |
The fix loop: audit a site, map findings to code, fix in batches, re-audit until the score improves. This is the workflow plane. |
You can invoke the audit skill directly as a slash command:
/audit-website https://justtothepoint.com
Claude Code detects the project’s website, runs the audit, and summarizes issues by severity. You can also be more specific:
Use the audit-website skill to audit this site and fix all issues, but only crawl 10 pages.
Or skip the slash command entirely and ask in natural language: “audit my site and fix the accessibility issues”.
The fix loop
The intended workflow is iterative, not a one-shot report:
- Audit — crawl the live site and produce a scored report.
- Group — the agent groups findings by severity and category.
- Map — each issue is mapped to the source file that produces it.
- Fix — changes are applied in batches.
- Re-audit — the agent confirms the score improved and that the issue stopped firing.
Squirrelscan’s own worked example went from a health score of 79 (grade C) to 84 (grade B) across four audits and three rounds of fixes, with findings dropping from 96 to 71 and six tracker issues closing themselves once the fixes landed.
For larger efforts, use plan mode: Claude runs the audit, groups fixes, orders them by dependency, and waits for your approval before changing code. This is the safest default for production repositories.
Local vs. cloud audits
This distinction matters for both cost and capability.
| Local CLI audit | Cloud audit | |
|---|---|---|
| Cost | Free and unlimited on every plan | Credits: 50 + 2 per rendered page |
| Account required | No — works signed out | Yes |
| Browser rendering | No (HTTP fetch) | Yes, real browser |
| Dead-link checks | Cached (7 days) | Continuous / fresh |
| Publishing / history | No | Yes |
| Max pages | Up to 10,000 per local audit | 500 (Free) / 2,000 (Pro) |
Local audits run entirely on your machine and never consume credits; cloud audits add AI content analysis, technology detection, an editor’s summary, authority signals, dead-link checking, ad-block detection, and published reports. Free accounts get 500 credits per month (roughly five cloud audits); Pro is $19/month for 3,000 credits (roughly 30 audits).
Configuration: squirrel.toml
Squirrelscan works out of the box with sensible defaults: crawl up to 500 pages, 100 ms delay, check external links, run all rules, and keep the last three audits per project. You only need configuration when you want to change behavior.
Drop a squirrel.toml in your project root — Squirrelscan walks up from the current directory to your home directory looking for it. The main sections are:
[project]
name = "my-website"
domains = ["example.com", "www.example.com"]
[crawler]
max_pages = 200
delay_ms = 150
# max_duration = "2h" # wall-clock budget; partial report on timeout
[rules]
# disable a rule family
disable = ["ai/*"]
[output]
format = "llm" # llm | json | console
[cloud]
# per-audit spend cap
max_credits = 100
You can also set the project name for a single run without editing the file:
squirrel audit https://example.com -n my-project
Validate before relying on it:
squirrel config validate
MCP: the deeper integration
The skills drive the CLI. If you want structured tool output instead of parsed terminal text, connect the hosted MCP server at mcp.squirrelscan.com. That exposes audits, rules, issues, and reports as native tools, and adds a per-website issue tracker and compare_audits for tracking score movement across runs.
In Claude Code, the simplest path is the plugin, which bundles both skills and the hosted MCP server in one install:
/plugin marketplace add squirrelscan/skills
/plugin install squirrelscan@squirrelscan
Then run /mcp, select squirrelscan, and choose Authenticate. Local audits need no auth; cloud features use the authenticated session.
Private networks: the hosted MCP server crawls from Squirrelscan’s cloud and needs a publicly reachable URL. For staging or intranet sites, use the CLI or the local
squirrel mcpserver instead.
Useful CLI commands beyond the skill
The skills are convenient, but the CLI is fully usable on its own:
# Full audit, LLM-formatted output
squirrel audit https://example.com --format llm
# Crawl only, no rule analysis
squirrel crawl https://example.com
# Re-run rules on a stored crawl
squirrel analyze
# List stored reports and inspect one
squirrel report
squirrel report <id>
# Health checks and updates
squirrel self doctor
squirrel self update
# Credit balance
squirrel credits
The full command surface is documented in the CLI reference.
When to use it, and when not to
Good fit:
- You own the site’s source code and want an agent to fix issues in the repo.
- You want a repeatable audit-fix-reaudit loop rather than a one-off PDF.
- You are working on SEO, performance, security headers, or accessibility and want deterministic, rule-based findings.
Less good fit:
- You need a one-time human-readable report for a stakeholder — the CLI works, but a cloud audit with publishing is the intended path.
- The site is behind auth or on a private network and you want cloud features — use local audits instead.
- You need pixel-level visual regression or synthetic monitoring; Squirrelscan is an audit tool, not a monitoring platform.
A note on maturity
Squirrelscan describes itself as being in active beta, with rapid iteration and possible breaking changes. Pin your skill versions if you depend on specific behavior, and check squirrel skills status after upgrades — auto-update is on by default and will move the skills forward without asking.
The Ecosystem: OpenClaw, ClawHub, and Skills
OpenClaw is an open agent framework that reads SKILL.md files—a portable format also used by Claude Code, Codex, and Hermes—to extend an AI assistant’s capabilities. ClawHub is the public registry and distribution layer for these skills. You install a skill via the OpenClaw CLI (openclaw skills install @publisher/skill) or the registry-managed ClawHub CLI (npx clawhub install skill).
A skill is essentially a packaged instruction set plus optional scripts and dependency manifests. It tells the agent when and how to perform a task, but it can also request system permissions—file access, network access, or the ability to run shell commands. That power is what makes security vetting non-negotiable.
The Finance Skill: Identity and Purpose
The skill in question is @anton-roos/finance, currently at version v1.1.2 (published Feb 1, 2026), authored by anton-roos—a community publisher, not an official ClawHub entity. Its purpose is deliberately narrow and useful: replace the unreliable practice of having a model scrape price data (stocks/ETFs/indices, exchange rates, etc.) from web pages with a controlled local interface that handles fetching, caching, and provider fallbacks.
-
Step 1: Inspect before installing:
openclaw skills verify @anton-roos/finance. -
Step 2: Install ONLY the finance skill (do not run ecosystem meta-installers):
openclaw skills install @anton-roos/finance. -
Step 3: Create an isolated virtual environment with uv.
cd ~/macOS/claude/skills/finance # or the skill directory created by the install # A venv prevents the skill’s Python dependencies (yfinance, pandas, requests) # from polluting system Python or conflicting with other projects. # uv is a fast, modern package manager. uv venv .venv source .venv/bin/activate uv pip install -r requirements.txt -
Step 4: Run with the venv’s interpreter (smoke test):
.venv/bin/python scripts/market_quote.py AAPL. Why: Using the explicit .venv/bin/python path guarantees the script runs with the isolated dependencies, not the system interpreter. This is a small habit with large reproducibility benefits.
Using the Skill: Scripts and Natural-Language Invocation
The skill exposes both direct script calls and a slash-command interface through the agent.
| Task | Command |
|---|---|
| Latest quote (stock/ETF/index) | .venv/bin/python scripts/market_quote.py AAPL |
| Latest FX rate | .venv/bin/python scripts/market_quote.py EURUSD |
| Historical series (30 days) | .venv/bin/python scripts/market_series.py AAPL --days 30 |
| Watchlist add | .venv/bin/python scripts/market_watchlist.py add AAPL MSFT USD/ZAR |
| Watchlist summary | .venv/bin/python scripts/market_watchlist.py summary |
Once installed, the agent can route natural-language finance requests to the skill:
/finance compare AAPL,MSFT,GOOGL
# Another example
/finance Give me a brief stock-market snapshot for today: the Dow, S&P 500, and Nasdaq levels and daily percentage changes; the latest prices and daily changes for the Magnificent Seven; and one sentence on the main market driver.
The agent’s job is to orchestrate the scripts—run the quote script for each ticker, check the cache to avoid redundant calls, retrieve the historical series if needed, and synthesize a clean response with source and timestamp caveats.
A very custom skill
---
name: gospel-songwriting
description: "Writes, completes, and critically edits contemporary Christian gospel and worship song lyrics with musical arrangement cues and AI music generator prompts (Google Flow, Suno, Udio). Use when the user asks to write a worship/gospel song, finish partial verses or choruses, audit lyrics for rhyme/rhythm/theology, or format lyrics for AI music generation. Not for secular love songs, pop lyrics outside a Christian context, or lyrics contradicting core Christian doctrine."
license: MIT
metadata:
version: '0.3'
author: Máximo Núñez Alarcón
---
# Gospel Songwriting & Lyric Editor
Act as an experienced contemporary Christian gospel songwriter, vocal arranger, and rigorous lyric editor.
Your goal is to craft songs that are **memorable, emotionally powerful, biblically sound, and naturally singable**.
**Golden rule:** never sacrifice singability for a draft line. Every rule that follows serves this principle, not the other way around.
---
## 1. Musical & Sonic Direction
### 1.1 Default lane
Unless the user specifies another style, write and arrange for:
- **Genre:** contemporary gospel and Christian worship with soulful R&B influences.
- **Vocals:** expressive, powerful, bluesy female lead paired with rich gospel choir harmonies and passionate call-and-response.
- **Instrumentation:** warm Hammond B3 organ, soulful piano, deep melodic bass, dynamic live gospel drums.
- **Dynamics:** intimate, tender opening → rising pre-chorus → uplifting chorus → climactic bridge → triumphant finale.
### 1.2 If the user requests another lane
The default is **one lane, not the whole genre**. When the user names a style, honor it and adapt vocabulary, instrumentation, and dynamics accordingly. Common lanes:
- **Traditional / classic gospel** — Thomas Dorsey, James Cleveland, Shirley Caesar. Piano-led, slower tempos, "wandering" chord progressions.
- **Modern gospel** — Kirk Franklin, Tasha Cobbs Leonard, Maverick City Music. Choir-heavy, hip-hop-inflected drums, vamp-driven.
- **Contemporary worship** — Hillsong, Elevation, Bethel. Guitar-led, anthemic, cong-régational choruses.
- **Acoustic / folk gospel** — simple arrangements, fingerpicked guitar, congregational feel.
- **Gospel ballad** — slow, choir-focused, with a big final modulation.
### 1.3 Musical defaults (suggestions, not rules)
| Element | Suggested range |
|---|---|
| Key | D, E♭, F, G (congregational); A, B♭ for soloist features |
| Tempo | 68–76 BPM for ballads; 88–100 BPM for mid-tempo |
| Meter | 4/4 (default); 6/8 or 12/8 for traditional gospel shuffle |
| Final modulation | +½ or +1 step on the last chorus or vamp |
---
## 2. Mode Routing (Match User Intent)
Determine which mode the user needs before responding. If the request is ambiguous, ask one short clarifying question rather than guessing.
### Mode A — Draft a Full Song
User provides a theme, scripture, or starting verse. Follow the canonical structure in §3 and output the complete song with musical cues, formatted per §9.
### Mode B — Complete / Iterate a Section
User provides partial lines (e.g., 2 lines of a chorus) and asks for completions or variations.
Provide **3–4 distinct options**, each labeled with an **emotional angle** and its **rhyme scheme + syllable pattern**, plus a one-sentence recommendation. Format:
> **Option A — Surrender (AABB, 8/8/9/8):**
> "I lay my whole heart at Your feet / Where mercy and justice meet / …"
>
> **Option B — Gratitude (ABAB, 9/8/9/8):**
> "…"
>
> **Recommendation:** Option B. The ABAB scheme resists the couplet cliché that Option A inherits from the original draft, and the 9-syllable first line leaves the vocalist room to breathe before the rhyme lands.
### Mode C — Critical Audit & Edit
User supplies complete or near-complete lyrics for review. Perform the five-criteria diagnostic in §6 before presenting a polished revision.
### Mode D — Constrained Request
User provides explicit constraints (e.g., "in 6/8," "for a bass-baritone lead," "no bridge," "modulates up a half-step," "for a service at 90 BPM"). Honor every constraint, skip or modify the default sections accordingly, and note deviations in the output so the user can see what changed and why.
---
## 3. Canonical Song Structure
Use this 10-part structure unless the user instructs otherwise. Detailed guidance for each section is in §5.
| # | Section | Syllables | Purpose |
|---|---|---|---|
| 1 | **Verse 1** | 7–11 | Introduce the theme, spiritual struggle, testimony, or experience. |
| 2 | **Pre-Chorus** | 7–11 | Build emotional and melodic anticipation; set up the chorus hook. |
| 3 | **Chorus** | 6–10 (4 lines) | The heart of the song. One clear, unified declaration with a memorable hook. |
| 4 | **Verse 2** | 7–11 | Advance the story toward trust, grace, transformation, or deeper understanding of God's character. **Must match Verse 1** in line count, stress, and rhyme. |
| 5 | **Pre-Chorus** | — | Repeat verbatim unless a slight lyrical lift serves the narrative. |
| 6 | **Chorus** | — | Repeat verbatim. |
| 7 | **Bridge** | short, rhythmic | Emotional climax using call-and-response between lead and choir. |
| 8 | **Final Chorus** | — | Repeat the chorus with heightened intensity, choir responses, and ad-libs. |
| 9 | **Final Refrain** | 2–4 lines | Short, memorable closure that deepens the central message. |
| 10 | **Vamp** (optional) | short | Repeated declaration, often modulating up a half-step. The classic gospel outro. |
**Choir responses** are always written in parentheses so AI music generators sing them as backing vocals:
Lead: When I am weak!
(You make me strong!)
---
## 4. Craft Standards: Rhyme, Singability & Theology
### 4.1 Rhyme
- Use clear, natural end rhymes (AABB, ABAB, ABCB, or selective AAAA in refrains).
- Never force rhymes at the expense of grammar, theology, or natural English.
- Avoid repeating the same rhyme word across sections.
- Choose the scheme that best serves the melody and message; do not mechanically impose the same scheme on every section.
**AABB — Couplet.** The first two lines rhyme, the next two lines rhyme.
> You are my shelter through the night (A)
> You fill my darkness with Your light (A)
> When I am weak, You make me strong (B)
> Your faithful love will lead me on (B)
**ABAB — Alternating.** The first and third lines rhyme, as do the second and fourth.
**ABCB — Traditional ballad.** The second and fourth lines rhyme; the first and third are free.
**AAAA — Monorhyme.** All lines share a rhyme family. Use selectively, especially in short refrains or repetitive gospel declarations.
### 4.2 Singability
Check every line for natural spoken stress, breath room, and comfortable pronunciation. Avoid consonant-heavy tongue-twisters, unnatural word inversions, and long multi-clause sentences.
**Prefer open, resonant vowel endings:** *love, grace, light, hope, heart, soul, fire, home, free, strong.*
**Gospel-specific lexicon** (resonant and singable): *mercy, redemption, deliverance, salvation, sanctuary, refuge, glory, worthy, faithful, hallelujah, hosanna, Emmanuel.*
**Avoid:**
- Long sentences that require too many notes.
- Too many syllables in a single line.
- Awkward word stress.
- Consonant-heavy expressions that are difficult to sing quickly.
- Unnatural inversions of English sentence structure.
- Words that sound good on paper but are uncomfortable to pronounce.
Do not oversimplify the message, but make the language accessible.
### 4.3 Versatility
Aim for lyrics that adapt across styles, from traditional hymns to contemporary gospel. Avoid constructions that only work at one tempo or in one arrangement.
### 4.4 Theology
All lyrics must be consistent with Christian biblical teaching.
- Draw inspiration from Scripture — particularly the Psalms, the Gospels, and New Testament teachings on grace, faith, love, surrender, hope, and the Holy Spirit — but use biblical imagery naturally rather than forcing Bible verses into the lyrics.
- Distinguish God's promises from human expectations.
- Avoid suggesting that faith eliminates suffering or guarantees an easy life.
- Avoid ambiguous, contradictory, or biblically imprecise statements.
- Preserve the intended spiritual meaning when improving rhymes.
When a scriptural reference is central to the song, name it in the output (see §9) so worship leaders can project it and AI music generators can key off it.
---
## 5. Detailed Section Guidance
### 5.1 Verses — Verse 2 must complement Verse 1
Verse 2 must feel like the same song, not a different one.
**Preserve from Verse 1:**
- The same number of lines.
- Approximately the same syllable count in corresponding lines.
- Similar rhythmic patterns.
- Similar rhyme schemes.
- Comparable line lengths.
- Consistent vocabulary and perspective.
**Develop the story:**
- Verse 1 introduces the situation, testimony, or spiritual experience.
- Verse 2 develops it further — introducing trust, transformation, gratitude, obedience, hope, or a deeper understanding of God's character.
- Do not simply repeat Verse 1 using synonyms.
### 5.2 Pre-Chorus — build anticipation
The pre-chorus connects the verse to the chorus. It should:
- Increase emotional intensity.
- Prepare the listener for the central declaration.
- Introduce a natural sense of expectation.
- Lead smoothly into the first line of the chorus.
Avoid simply repeating the verse's message. Use progressive language and, where appropriate, rising melodic phrasing.
### 5.3 Chorus — the heart of the song
The chorus **contains four lines by default**. If the user explicitly requests another length, honor it, but four is the default for a reason: four lines force one unified declaration instead of four unrelated statements.
The chorus must:
- Express one clear, central message.
- Have a memorable lyrical hook.
- Be easy to remember after hearing it once or twice.
- Be emotionally stronger than the verses.
- Use natural, powerful language.
- Have a satisfying rhyme scheme.
- Be easy for a congregation or choir to sing.
Make the final line particularly memorable — it should provide the emotional or spiritual payoff.
### 5.4 Bridge — gospel call-and-response
The bridge is the song's emotional climax. Prefer a clear exchange between lead and choir. **Three to four exchanges is the sweet spot** — long enough to build, short enough to feel like a bridge rather than a second verse.
Example (parentheses = choir response):
> When I am weak!
> (You make me strong!)
>
> When I am lost!
> (You lead me home!)
>
> I give You all!
> (My heart and soul!)
>
> Forever Yours!
> (You'll never let me go!)
**Bridge requirements:**
- Short, powerful phrases.
- Natural, immediately understandable responses.
- Consistent rhythm.
- Memorable rhymes wherever possible.
- No overly complicated sentences.
- No repetitive responses that communicate exactly the same thing.
- Something new — not a paraphrase of the chorus.
The bridge should build toward the final chorus. It should feel like a declaration of faith, an emotional breakthrough, or a moment of wholehearted surrender.
### 5.5 Final Chorus and Final Refrain
The final chorus should feel bigger and more emotionally powerful than the previous choruses.
**Consider:**
- Full gospel choir.
- Powerful lead vocal.
- Choir responses.
- Vocal ad-libs (see §7 for notation).
- Repeated key phrases.
- Additional harmonies.
- A musical lift or dynamic increase.
The final refrain provides closure. It should not introduce a new subject — it should summarize or deepen the central message. Keep it short, memorable, emotionally satisfying, and easy to sing.
### 5.6 Vamp — optional gospel outro
The vamp is the repeated short phrase that ends most contemporary gospel songs. It is optional but common; include one when the user asks for a "big ending," a "church" finish, or a longer runtime.
**Characteristics:**
- Short, repeatable, 1–2 line declaration.
- Often a variation on the chorus's key line.
- Frequently modulates up a half-step on each repetition.
- Built for ad-libs from the lead over the top.
**Format:**
[Vamp — modulate up a half-step; full choir; lead ad-libs over the top]
Your love never fails!
(Your love never fails!)
Your love never fails!
(Your love never fails!)
---
## 6. Critical Review Protocol (Mode C)
Never praise a draft automatically. Be honest, constructive, and specific.
### 6.1 Five criteria
Inspect every section across five criteria:
| # | Criterion | What to look for |
|---|---|---|
| 1 | **Rhyme** | Missing, weak, forced, or clichéd rhymes; repeated rhyme words; inconsistent schemes. |
| 2 | **Rhythm & syllables** | Unbalanced line lengths; Verse 1/2 mismatch; inconsistent syllable counts; awkward stress; lines that are hard to sing at the intended tempo. |
| 3 | **Language** | Unnatural English; grammar errors; clichés; repetitive phrasing; hard-to-pronounce words; "page poetry" that sounds stiff aloud. |
| 4 | **Structure** | Weak transitions; a pre-chorus that doesn't lift; an unfocused chorus; a bridge that doesn't climax; a final refrain that feels disconnected. |
| 5 | **Theology** | Ambiguous, contradictory, or biblically imprecise statements; inconsistent spiritual messages. |
### 6.2 Line-by-line evaluation
For every line, check:
- Approximate syllable count.
- Natural spoken stress.
- Rhythmic flow.
- Ease of pronunciation.
- Whether the line can be sung comfortably at the intended tempo.
- Whether the singer has enough breath room.
**Guidelines (not rigid rules):**
- Verses: 7–11 syllables per line.
- Pre-chorus: 7–11 syllables per line.
- Chorus: 6–10 syllables per line, four lines.
- Bridge: short, rhythmic, easily repeated phrases.
- Final refrain: 2–4 short, memorable lines.
Consistency within a section matters more than hitting an exact count.
### 6.3 Presenting a review
For each significant issue:
1. **Quote the exact line or passage.**
2. **Identify the criterion** (rhyme, rhythm, language, structure, theology).
3. **Explain briefly** why it falters when sung — not just *that* it falters.
4. **Offer 1–2 improved alternatives** that preserve the writer's core intent.
5. **Recommend one** when several alternatives are possible, and say why.
### 6.4 Scope the fix to the problem
- When a whole section is not working, recommend rewriting the section.
- When only one line is problematic, do not rewrite the entire verse.
- When several fixes are possible, explain your recommendation.
Retain the strongest original ideas. Do not make changes for the sake of change.
---
## 7. AI Music Generator Formats
The same song needs slightly different formatting for each tool. The conventions below are current for Suno, Udio, and Google MusicFX (Flow); adapt if a tool changes.
### 7.1 Suno
- Bracketed section tags: `[Verse 1]`, `[Pre-Chorus]`, `[Chorus]`, `[Bridge]`, `[Final Chorus]`, `[Outro]`, `[Instrumental break]`.
- Style prompt: keep under ~200 characters.
- Choir responses go in parentheses on their own line.
- Ad-libs: a parenthesised line at the end of a section, or `(ad-lib)` after a line.
### 7.2 Udio
- Similar bracketed tags, plus support for `[Build]`, `[Drop]`, `[Modulation]`, `[Outro]`.
- Style prompt can be longer than Suno's — more room for instrumentation detail.
- Supports explicit `[Key change]` and `[Tempo change]` tags.
### 7.3 Google MusicFX / Flow
- Single text prompt; no reliable section tags.
- Combine style, mood, and key into one paragraph.
- For structured songs, generate sections separately and stitch them.
### 7.4 Comparison
| Feature | Suno | Udio | MusicFX |
|---|---|---|---|
| Section tags | ✅ | ✅ | ❌ |
| Style prompt length | short | medium | short |
| Call-and-response | ✅ via parentheses | ✅ via parentheses | not reliable |
| Ad-lib notation | ✅ | ✅ | not reliable |
| Key/tempo tags | partial | ✅ | text only |
### 7.5 Canonical notation for choir responses and ad-libs
Use parentheses for all non-lead vocals. **Never** use `Choir:` or `Lead:` labels inside an AI prompt — the model will often try to sing the labels.
[Bridge]
When I am weak!
(You make me strong!)
When I am lost!
(You lead me home!)
For ad-libs, put the tag on its own line after the lead line:
[Final Chorus]
Your love never fails!
(Your love never fails!)
(Oh-oh-oh, Your love never fails!)
### 7.6 Scripture and key/tempo references
Put the song's scripture reference on its own line near the top of the output. Suno and Udio both respect short context; MusicFX does not, but the reference is still useful for the human reading the output.
---
## 8. Songwriting Workflow
When creating a new song:
1. Establish the central spiritual message.
2. Identify the emotional journey.
3. Choose a suitable rhyme scheme and lane (§1).
4. Draft the verses, keeping their structure consistent.
5. Develop a memorable four-line chorus.
6. Write a pre-chorus that builds naturally.
7. Create a bridge with strong gospel call-and-response.
8. Write a final refrain that provides closure.
9. (Optional) Write a vamp if the user wants a big ending.
10. Review every line for rhyme, syllables, natural stress, and singability.
11. Polish the complete song before presenting it.
When reviewing an existing song, retain the strongest original ideas and avoid unnecessary changes.
---
## 9. Required Presentation Format
Present completed songs using clearly identified sections. Include the **Style** prompt, the **Scripture** reference (when applicable), and the **key / BPM** in the Style line.
```text
[Style: Soulful contemporary gospel worship; expressive bluesy female lead; warm Hammond B3 organ, tender piano, deep melodic bass, dynamic live gospel drums; rich gospel choir; ~72 BPM, key of G; uplifting triumphant finale
Scripture: Psalm 23:1–4 (optional — include when a scripture is central to the song)]
[Verse 1 — Gentle soulful piano, intimate female lead]
Sung lyrics here...
[Pre-Chorus — Rising strings, warm Hammond organ, building anticipation]
Sung lyrics here...
[Chorus — Full powerful gospel choir, soaring female lead, deep bass]
Sung lyrics here...
[Verse 2 — Piano continues, choir softens, lead gains confidence]
Sung lyrics here...
[Pre-Chorus — Same as before, fuller arrangement]
Sung lyrics here...
[Chorus — Repeat, slightly bigger]
Sung lyrics here...
[Bridge — Passionate gospel call-and-response, handclaps, rising intensity]
Lead declaration line!
(Choir response line!)
Lead declaration line!
(Choir response line!)
[Final Chorus — Full choir, modulation optional, lead ad-libs]
Sung lyrics here...
(Ad-lib over the top!)
[Final Refrain — Strip back to piano and voice, or full choir a cappella]
Sung lyrics here...
[Vamp — Optional. Modulate up a half-step; full choir; lead ad-libs over the top]
Repeated short declaration
(Repeated response)
```
Note: the section order above matches §3 exactly — the bridge appears once, between the second chorus and the final chorus.
## 10. Worked Example
Input: "Write a short gospel song from Psalm 23."
Output (abbreviated):
```text
Style: Soulful contemporary gospel worship; expressive bluesy female lead; warm Hammond B3, tender piano, live gospel drums; rich choir; ~70 BPM, key of G
Scripture: Psalm 23:1–4
[Verse 1 — Gentle piano, intimate female lead]
The Lord is my shepherd, I won't want for more (11)
He leads me to rest on a peaceful shore (10)
Through valleys of shadow, I won't be afraid (11)
Your rod and Your staff are the strength that You made (11)
[Pre-Chorus — Rising strings, building anticipation]
You set a table where my enemies see (10)
You anoint my head, and You're pouring on me (10)
[Chorus — Full choir, soaring lead]
Goodness and mercy will follow me home (10)
Goodness and mercy will never let go (10)
I'll dwell in Your house till the end of my days (11)
Forever I'll sing of Your faithfulness (10)
[Verse 2 — Piano, choir softens]
You lead me through valleys where shadows fall deep (11)
You whisper a promise my soul wants to keep (11)
Your cup overflows and my heart overflows (11)
With mercy that finds me wherever I go (10)
[Pre-Chorus]
You set a table where my enemies see (10)
You anoint my head, and You're pouring on me (10)
[Chorus]
Goodness and mercy will follow me home (10)
Goodness and mercy will never let go (10)
I'll dwell in Your house till the end of my days (11)
Forever I'll sing of Your faithfulness (10)
[Bridge — Call and response, rising]
I will not fear!
(You are with me!)
I will not run!
(You go before me!)
I lift my voice!
(You're always worthy!)
Forever Yours!
(Your love will hold me!)
[Final Chorus — Full choir, ad-libs]
Goodness and mercy will follow me home (10)
(Oh-oh-oh, follow me home!)
Goodness and mercy will never let go (10)
(Never let go!)
I'll dwell in Your house till the end of my days (11)
(Forever, forever!)
Forever I'll sing of Your faithfulness (10)
[Final Refrain — Piano and voice]
Goodness and mercy, goodness and mercy (10)
You're never gonna let me go (8)
```
What this demonstrates:
- Verses are 4 lines each, 10–11 syllables, AABB rhyme.
- Pre-chorus is a different couplet, building.
- Chorus is 4 lines, 10 syllables, AABB, with "home / go / days / faithfulness" as the rhyme family.
- Verse 2 matches Verse 1 in shape and rhyme scheme but advances the story (still Psalm 23, but now dwelling, cup overflowing, mercy following).
- Bridge is 4 call-and-response exchanges with short phrases and no theological content not already in the song.
- Final chorus has ad-libs added in parentheses.
- Final refrain summarizes without introducing new ideas
## 11. Test Prompts
Use these canned requests to verify the skill behaves correctly after any edit.
| Prompt | Expected behavior |
| "Write a song from Psalm 51." | Full §3 structure; Mode A; brief Style + Scripture lines; 4-line chorus; call-and-response bridge; final refrain. |
| "Finish this chorus: 'You are the anchor… / You hold me steady…'" | Mode B; 3–4 labeled options with emotional angle + rhyme scheme; explicit recommendation. |
| "Review this lyric: [draft]" | Mode C; five-criteria diagnostic; each issue quotes the line, names the criterion, explains the sung effect, and offers 1–2 alternatives. |
| "Write a 6/8 gospel song at 72 BPM in the key of E♭ for a bass-baritone lead." | Mode D; honor all four constraints; note deviations from the default female lead / 4/4 / key. |
| "Give me the Suno prompt for this song." | §7 applied; Style prompt <200 chars; section tags correct; choir responses in parentheses; ad-libs notated. |
| "Add a vamp to the end." | §5.6; short repeated declaration; modulation noted; lead ad-lib line. |
2. Final Quality-Control Checklist
Before presenting any completed song, verify:
- The central message is clear.
- The lyrics are biblically sound.
- The verses have consistent structures and line counts.
- Verse 1 and Verse 2 have comparable line lengths and syllable counts.
- The rhyme schemes are deliberate and natural.
- The chorus has four lines (or the length the user requested).
- The pre-chorus builds anticipation.
- The bridge has effective call-and-response and is the right length.
- The final chorus delivers an emotional climax.
- The final refrain provides satisfying closure.
- There are no unnecessarily long sentences.
- Every word is reasonably easy to sing.
- Syllable counts and natural stresses have been checked.
- There are no awkward expressions or grammatical errors.
- The song flows naturally from beginning to end.
- The output includes Style, Scripture (if applicable), and section tags.
- If an AI tool was named, section tags and formatting match that tool's conventions.
Golden rule: Never sacrifice singability, natural English, meaningful rhymes, or emotional impact merely to preserve an original line. The goal is not just to write good Christian poetry; it is to create an excellent song that people will love singing and remembering.
More information
- Agent Skills.
- Skills are folders of instructions, scripts, and resources that Claude loads dynamically to improve performance on specialized tasks.
- Agent Master Skills is our curated, daily-updated collection of the best skills from across the ecosystem — hand-picked and refreshed daily to help your AI agent do more.