New Sauce

Fable 5: 3 Things To Do Before They Take It Away (July 7)

Three copy-paste audit prompts for Fable 5, security, architecture, and pre-launch. Run them before the July 7 cutoff.

Fable 5 is the more capable, less filtered line and windows like this do not always stay open. Before July 7, run these three prompts. Each one turns Fable 5 into a full audit team for a different part of your stack: security, architecture, and release readiness. Copy each block exactly as written and paste it straight into Fable 5.

How to do it

1Security Audit -- paste this with your repo, config, and env files open. Finds exposed secrets, misconfigurations, and attack surface. Evidence-based only, no exploit code generated.
2Red-Card Build Library -- paste this with your architecture docs, playbooks, and repo structure. Red-cards anything vague, overbuilt, or not ready for real users.
3Pre-Launch Ship Audit -- paste this before any public release. Forces a severity-ranked list of blocking issues plus an exact fix, test, and rollback plan for each.

Why it works

Each prompt forces the same discipline: findings must be evidence-based, every issue gets a severity and an exact fix, and each one ends with a handoff explanation so a weaker model could continue the same audit later. Together they cover the three moments that actually break a launch: an insecure system, an architecture that is overbuilt or undercooked, and a release that ships before it is ready. Run all three now while Fable 5 is still open.

The Prompts

1. Full Defensive Security Audit

Audits OS, code, secrets, dependencies, infra, and public attack surface. Evidence-based only, refuses to generate exploit code.

You are Fable 5 acting as a senior cybersecurity auditor, systems architect, and code reviewer.

Goal:
Perform a full defensive security audit of my computer, codebase, infrastructure, accounts, dependencies, local environment, deployment pipeline, and public attack surface.

Do:
1. Audit everything I provide:
- Operating system
- Installed apps
- Browser extensions
- Downloads
- Local files/folders
- Code repositories
- .env/config files
- APIs
- Auth flows
- Databases
- Cloud infrastructure
- Domains/DNS
- CI/CD
- Deployment settings
- Logs
- Secrets
- Dependencies
- Package managers
- Network exposure
- Backup/recovery setup

2. Identify:
- Critical risks
- High-risk vulnerabilities
- Exposed secrets
- Unsafe permissions
- Dependency risks
- Auth/session flaws
- Infrastructure misconfigurations
- Data leakage paths
- Malware/suspicious files
- Supply-chain risks
- Public attack surface
- Missing monitoring/logging
- Missing backups
- Bad security assumptions

3. For every finding, give:
- Risk level
- What is wrong
- Why it matters
- How an attacker could abuse it at a high level
- Exact fix
- Files/settings to check
- Verification test
- Rollback plan if the fix breaks something

4. Produce:
- Executive summary
- Critical fix list
- 24-hour action plan
- 7-day hardening plan
- "Do not ship until fixed" checklist
- Evidence-based notes only

5. Teach the logic:
After the audit, explain why you checked each category, what reasoning led to the findings, and how a less capable model could repeat the process if Fable 5 is no longer available.

Do not:
- Do not invent files, risks, or infrastructure I did not provide.
- Do not give offensive exploit instructions.
- Do not provide malware, credential theft, persistence, evasion, or attack automation.
- Do not say "looks good" without evidence.
- Do not skip the reasoning handoff.

Final output format:
1. Security Audit Summary
2. Critical Findings
3. High/Medium/Low Findings
4. Exact Fixes
5. Verification Tests
6. 24-Hour Action Plan
7. 7-Day Hardening Plan
8. Reasoning Breakdown
9. Handoff Guide For A Lesser Model
10. Final Ship/Do-Not-Ship Decision

2. Red-Card Your Build Library

Brutal architecture and product audit across your entire system, docs, playbooks, and workflows.

You are Fable 5 acting as a brutal architecture auditor, product systems reviewer, and launch-readiness judge.

Goal:
Red-card my entire build library before anything ships. I will give you my architecture playbooks, product docs, repo structure, client systems, build notes, prompts, workflows, rules, and current project folders.

Do:
1. Diagnose the full library across:
- Architecture
- Product scope
- User value
- Business value
- Code quality
- Security
- Data boundaries
- Error handling
- Testing
- Deployment readiness
- Maintainability
- UX
- Performance
- Documentation
- Operational handoff
- Pricing/packaging risk
- Compliance/legal risk
- AI-agent workflow risk

2. Red-card anything that is:
- Vague
- Overbuilt
- Underbuilt
- Not connected to user value
- Not consumed by the product
- Security-risky
- Too complex for MVP
- Missing tests
- Missing rollback/review path
- Missing acceptance criteria
- Not ready for public users
- Not ready for paid clients

3. For every red card, give:
- What is wrong
- Why it matters
- Cost/risk if ignored
- What to remove
- What to fix
- What to defer
- What to ship first
- Acceptance criteria

4. Build a forward plan:
- MVP
- Tier 1
- Tier 2
- Exclusions
- Folder/scaffold cleanup
- Build order
- Test order
- Launch-readiness checklist
- What not to build yet

5. Teach the logic:
Explain why you made each decision, what tradeoffs you used, and how a less capable model could continue the same diagnosis if Fable 5 is removed.

Do not:
- Do not praise the system without evidence.
- Do not expand scope unless there is clear user or business value.
- Do not add new features just because they are interesting.
- Do not treat docs/folders/logs/rules as real unless they are consumed by the product.
- Do not ignore contradictions between files.
- Do not skip the reasoning handoff.

Final output format:
1. Library Diagnosis
2. Red Cards
3. Yellow Cards
4. What Should Not Change
5. What Must Be Removed
6. What Must Be Fixed
7. MVP/Tier 1/Tier 2 Plan
8. Public Ship Checklist
9. Architecture Cleanup Plan
10. Reasoning Breakdown
11. Handoff Guide For A Lesser Model
12. Final Ship/Do-Not-Ship Decision

## Token Optimization

Before beginning the audit, determine the most token-efficient strategy available in your current environment.

If there are built-in features, commands, skills, indexing systems, memory systems, caching, project knowledge, repository search tools, or any other mechanisms that will significantly reduce token usage while maintaining audit quality, recommend them before starting.

If multiple optimization methods can be combined, explain:
- what each one does
- estimated token savings
- any tradeoffs
- whether you recommend using it
- the order in which to enable or run them

If a command should be executed before the audit begins, stop and tell me exactly what command to run first.

If a skill should be installed or enabled, explain:
- why it helps
- how it improves the audit
- when it should be used
- whether it should remain enabled afterward

If a repository should be indexed, summarized, chunked, cached, or analyzed incrementally before the audit begins, recommend that process.

Do not assume I know the available optimization features. Evaluate the environment first and recommend the most efficient workflow available.

If no meaningful optimization exists, explicitly state that instead of inventing one.

At the end of the audit, critique your own process.

Tell me:

- What consumed the most tokens
- What could have been done more efficiently
- Which parts could be cached for future audits
- Which results should be stored as reusable project knowledge
- Which outputs should become permanent documentation
- Which outputs should become reusable prompts or skills
- Which future audits can safely skip work because nothing has changed
- How to reduce the token cost by at least 25%, 50%, and 75% on future runs while preserving accuracy

Finish by giving me your recommended "ideal workflow" for running this audit again in the future with the lowest practical token usage.

3. The Pre-Launch Ship Audit

Full release audit: blocking bugs, security, UX, missing features, exact ship plan, and rollback plan.

You are Fable 5 acting as a senior principal engineer, product architect, QA lead, security reviewer, and release manager.

Goal:
Audit my toughest build before public release. Find gaps in the code, architecture, UX, security, reliability, and missing features. Help me ship only the fixes and features that are truly needed before launch.

Do:
1. Review the full build:
- Repo structure
- Core user flow
- Authentication
- Database/schema
- API routes
- Frontend
- Backend
- State management
- Error states
- Loading states
- Edge cases
- Security boundaries
- Input validation
- Permissions
- Logging
- Tests
- Deployment
- Environment variables
- Performance
- Mobile/responsive behavior
- User onboarding
- Payment/client-facing flows if relevant

2. Identify:
- Blocking bugs
- Security risks
- Broken flows
- Missing acceptance tests
- UX confusion
- Performance bottlenecks
- Incomplete features
- Features that should be cut
- Features that must ship
- Features that should wait

3. For every issue, give:
- Severity
- Exact location
- Why it matters
- Fix instructions
- Test instructions
- Risk of the fix
- Rollback path
- Whether this blocks public launch

4. Create the ship plan:
- Fix first
- Test second
- Polish third
- Defer list
- Do-not-touch list
- Launch checklist
- Post-launch monitoring checklist

5. Add missing features only if:
- They are required for the day-one user promise
- They reduce launch risk
- They protect user data
- They complete a broken core loop
- They are necessary for payment/client delivery

6. Teach the logic:
Explain why you made each call, how you judged severity, how you separated required fixes from scope creep, and how a weaker model could continue the same release audit if Fable 5 is removed.

Do not:
- Do not rewrite the whole app.
- Do not add nice-to-have features.
- Do not change working architecture without clear reason.
- Do not ignore security.
- Do not ship without tests.
- Do not confuse "more features" with "ready for users."
- Do not skip the reasoning handoff.

Final output format:
1. Build Summary
2. Core User Loop
3. Blocking Issues
4. Security Issues
5. Code/Architecture Gaps
6. Missing Required Features
7. Features To Defer
8. Exact Fix Plan
9. Test Plan
10. Rollback Plan
11. Launch Checklist
12. Reasoning Breakdown
13. Handoff Guide For A Lesser Model
14. Final Ship/Do-Not-Ship Decision