DEV Community: ANIRUDDHA ADAK

Windows Said No: The Long Path Bug That Broke Vector Storage in Cognee

ANIRUDDHA ADAK — Thu, 30 Jul 2026 14:35:00 +0000

Some bugs only appear when you have a long path, a Windows machine, and a vector database that spawns a subprocess. This is the story of the one that taught me why cross platform really matters.

Who I am

I am Aniruddha Adak, GitHub @aniruddhaadak80, a full stack and AI engineer from Kolkata. I love working on Python, Next.js, TypeScript and agent frameworks.

My open source journey started with a simple card addition in 2024 and grew to 29 plus merged PRs across projects like topoteretes/cognee, openclaw/openclaw, NousResearch/hermes-agent, google-gemini/gemini-cli.

This post is my entry for Smash Stories for DEV Summer Bug Smash 2026. It is the chaotic story behind one of my favorite bug fixes, and how Google Antigravity helped me smash it.

The setting, a bug that only Windows users saw

Picture this. You are building a RAG pipeline with Cognee. On Mac and Linux, everything works fine. You push your code, a contributor on Windows tries it, and suddenly you get OSError: [WinError 3] The system cannot find the path specified.

It happens inside LanceDB, when Cognee tries to persist vector data to the local filesystem.

The issue was #2941 in cognee. It was not a random error. It was a systematic Windows limitation colliding with how LanceDB spawns subprocesses.

On Windows, there is a legacy MAX_PATH limit of 260 characters. When paths get long, you need to prefix them with \\?\ to tell Windows to allow long paths. Most Python code forgets this, because on Unix you never need it.

Cognee was building absolute paths like C:\Users\aniruddha\projects\cognee\.data\vector_db\... and passing them to LanceDB, which then created even deeper nested files. On long project paths, the final path crossed 260 characters and Windows refused to create it, but only when LanceDB tried to access it from a subprocess.

This is the kind of bug that never shows up in CI if your CI only runs on Ubuntu.

The chaos, why it was hard to catch

This bug was hard to catch for many reasons. It was OS specific and only appeared on Windows with long project paths. It was indirect because the error came from LanceDB, not from Cognee code directly. It was path dependent because short paths worked and long paths failed. It was subprocess related because the main process could sometimes create the folder, but the child process could not see it without the long path prefix.

I saw many users reporting similar issues but blaming LanceDB. The real fix needed to be in Cognee, where the vector_db_url is normalized.

How I approached it with Antigravity and Google AI

This is where my workflow changed. I used Antigravity agentic IDE with Gemini 2.5 Pro for the entire investigation.

For step one, understanding the codebase, I asked Antigravity where vector_db_url is constructed and how it is passed to LanceDB. It traced the flow from config to LanceDB adapter in seconds.

For step two, reproducing mentally, I asked Gemini to explain Windows long path prefix rules and when \\?\ is needed for absolute paths. It explained the \\?\ and \\?\UNC\ rules and that you must normalize with os.path.abspath first.

For step three, writing the fix, I prompted Antigravity to create a helper that safely prefixes Windows absolute paths with \\?\ if not already prefixed, and leaves relative and Unix paths untouched. Antigravity suggested using os.name == 'nt' check and handling both drive letter paths and UNC paths.

For step four, testing on Windows, I wrote the logic to be testable on any OS and then validated it later on a Windows VM via Crabbox. This is the same approach I used for openclaw PR 90275.

For step five, edge cases, I asked Gemini to list edge cases. It gave me a clear list. Already prefixed paths should not be double prefixed. Relative paths should be left alone. Unix paths should be left alone. UNC paths need \\?\UNC\ handling. None or empty strings should be handled safely.

This collaboration made the fix robust and it is why I am submitting for Best Use of Google AI.

The fix that got merged

My merged PR is fix(lancedb): automatically prefix windows paths to resolve OS Error 3 for long paths in cognee. The PR link is https://github.com/topoteretes/cognee/pull/3123 and it is merged and released.

What the code does now

import os

def normalize_vector_db_url(url: str) -> str:
    if os.name != 'nt':
        return url

    if url.startswith('\\\\?\\'):
        return url

    abs_path = os.path.abspath(url)

    if abs_path.startswith('\\\\'):
        return '\\\\?\\UNC\\' + abs_path.lstrip('\\')

    return '\\\\?\\' + abs_path

Then this normalized path is used when constructing the LanceDB connection. The subprocess now receives a path that Windows understands as long path enabled.

In simple terms, we tell Windows explicitly, this path is allowed to be long, please do not block it.

Before versus after

Before this fix, on Windows with deep project structure, lancedb subprocess fails with OS Error 3. After this fix, same structure works, because the path is prefixed automatically. No user action is needed. That is the best kind of fix, invisible to the user.

Other merged bug fixes that shaped this story

This was not my only Windows related battle. Here are all my merged bug related PRs that taught me cross platform thinking. All are merged only and no drafts are included.

Project	PR Title	What it fixed	PR Link
topoteretes/cognee	fix(lancedb): automatically prefix windows paths	OS Error 3 on Windows long paths	https://github.com/topoteretes/cognee/pull/3123
openclaw/openclaw	test: make install-safe-path symlink tests compatible with Windows	3 symlink tests skipped on Windows, now run with junctions	https://github.com/openclaw/openclaw/pull/90275
NousResearch/hermes-agent	fix(permissions): handle None response from ACP request_permission	Crash on empty permission response, now fails safe	https://github.com/NousResearch/hermes-agent/pull/13457
Tracer-Cloud/opensre	fix: Database logic expansion for QA Edge Cases	AI misreading storage and WAL metrics, now handles red herrings	https://github.com/Tracer-Cloud/opensre/pull/626

Each of these is merged, no drafts, no closed without merge.

Lessons from the trenches

Cross platform bugs are real bugs. If your library claims to work on Windows, test the file paths on Windows. Subprocesses have different path rules. What works in your Python process may fail in a child process. Long paths are still a thing in 2026. Many tools still hit MAX_PATH. AI does not replace debugging, it accelerates it. Gemini helped me map the code and list edge cases, but I still had to understand Windows internals. Small fix, large impact. This 20 line helper unblocked every Windows user with a nested project.

How Antigravity became my debugging partner

I want to be clear about my setup because the challenge asks for Best Use of Google AI. I use Antigravity as my daily IDE for open source contributions. I use Gemini 2.5 Pro inside it for codebase search and call graph analysis, for writing reproduction scripts, for generating test cases for edge cases, and for drafting PR descriptions that maintainers love.

For this cognee bug, Antigravity reduced my exploration time from hours to minutes. I could focus on the actual Windows logic instead of hunting files.

I build with AI, but I ship with responsibility. Every line is reviewed by me before it is merged.

Final thoughts

This bug taught me that the most legendary bugs are not loud. They are quiet, they only appear on one OS, on one condition, and they make a user think they did something wrong.

My job as a contributor is to make sure they do not have to think that.

If you are reading this and you work on a library that touches the filesystem, please test on Windows with a long path. You will be surprised what you find.

Links and credits

GitHub is https://github.com/aniruddhaadak80
Merged fix is https://github.com/topoteretes/cognee/pull/3123
Issue fixed is https://github.com/topoteretes/cognee/issues/2941
Challenge page is https://dev.to/bugsmash

My Summer of Sleuthing: 373 Merged PRs and the Bugs That Taught Me Everything

ANIRUDDHA ADAK — Sat, 25 Jul 2026 15:57:00 +0000

This is a submission for DEV's Summer Bug Smash: Smash Stories powered by Sentry.

"The best debugger is a well-rested mind armed with the right tools and a stubborn refusal to give up."

The Call to Adventure

It started like any other day. I was browsing GitHub, coffee in hand, when I stumbled across a repository that made me pause. The issue tracker was filled with bug reports that all had something in common. They were being ignored. Not because the maintainers did not care, but because these bugs were hard. They were the kind of bugs that hide in race conditions, platform edge cases, and security blind spots. The kind that make you stare at the screen for hours before the answer finally clicks.

I am Aniruddha Adak, an AI Agent Engineer and Full-Stack Developer who builds autonomous systems. You can find my work on GitHub, read my blog at aniruddha-adak.vercel.app, or follow me on X and DEV.

Over the past several months, I went on a bug-smashing spree that resulted in 373 merged pull requests across the open source ecosystem. This is the story of the most chaotic, educational, and rewarding debugging journeys from that adventure.

Story One: The Security Breach Nobody Saw Coming

The Project

cognee is an open source AI memory infrastructure project. Think of it as the long-term memory system for AI agents. It stores, retrieves, and connects knowledge across conversations. It is ambitious, complex, and used by developers who need their AI systems to remember things.

The Discovery

I was reviewing the API layer, tracing how settings were updated. The POST /api/v1/settings endpoint caught my attention. It accepted a JSON payload and updated global configuration directly. No privilege check. No role verification. Just raw, unauthenticated power handed to anyone with a login token.

My stomach dropped.

In a production deployment, this meant any user could change LLM API keys, modify database connections, alter authentication settings, or disable security features entirely. This was not a subtle bug. This was a full system takeover waiting to happen.

The Investigation

I opened the codebase in the Antigravity agentic IDE and asked the AI to trace the authorization flow. Within seconds, it mapped the middleware stack and identified the gap. The settings route was registered without the admin guard that protected other sensitive endpoints.

I checked the test suite. There were tests for settings updates, but none tested authorization failure. The bug had been sitting there, invisible to the test suite, invisible to code review, invisible to everyone.

The Fix

fix(security): restrict global settings and disable public registration #3115

aniruddhaadak80 posted on Jun 20, 2026

Closes #3084

This PR addresses the security vulnerabilities reported in #3084:

Requires superuser privileges for POST /api/v1/settings to prevent global configuration takeover.
Fully masks LLM and VectorDB API keys in GET /api/v1/settings to prevent leaking key prefixes.
Adds a COGNEE_PUBLIC_REGISTRATION_ENABLED environment variable to allow administrators to disable public self-registration.

View on GitHub

The fix was two lines of code. A decorator. require_superuser(). That was it. Two lines that closed a security hole you could drive a truck through.

I also masked LLM credentials in the response payload so that even authorized users would not see sensitive API keys in settings read responses.

The Lesson

The simplest fixes are often the most important. This two-line change had more security impact than any complex feature I could have built. Always audit your authorization matrix. Always test the negative cases. Always assume that if a permission check is missing, someone will find it.

Story Two: The Windows Path That Broke Everything

The Discovery

A user reported OS Error 3 on Windows when using local vector database storage. The error message was cryptic. The path looked fine. But LanceDB subprocesses were failing to open database files.

The Deep Dive

I fired up Antigravity and asked the AI to research Windows path handling. The answer came back immediately. Windows has a legacy maximum path length of 260 characters. When you exceed that, the API returns Error 3: The system cannot find the path specified. Even though the path exists.

The fix is to use the \\\\?\\ prefix, which enables extended-length paths up to 32,767 characters. But you cannot just slap that prefix on every path. It only works with absolute paths. It breaks relative paths. And it is Windows-only.

The Investigation

I traced the vector_db_url through the cognee codebase. The path was being constructed in Python, passed to LanceDB, which then spawned a subprocess. The subprocess was where the failure occurred. The prefix needed to be added at the exact point where the path crossed from Python into the native layer.

I spun up a Windows VM and reproduced the bug. The path was only 180 characters, well under 260. But LanceDB was adding its own internal directory structure, pushing the effective path past the limit. The error was happening in code the user never saw.

The Fix

fix(lancedb): automatically prefix windows paths to resolve OS Error 3 for long paths (fixes #2941) #3123

aniruddhaadak80 posted on Jun 20, 2026

Closes #2941

This PR automatically normalizes and prefixes absolute Windows paths for the vector_db_url when using local filesystem storage. This resolves OS Error 3 triggered by LanceDB subprocesses when generating long file paths for persisting vector data on Windows.

View on GitHub

I implemented runtime platform detection. On Windows, the code now normalizes the path to absolute form and adds the extended-length prefix before passing it to LanceDB. On Linux and macOS, the path is passed through unchanged.

The key insight was that the fix had to be transparent. Users should not need to know about Windows path limits. The software should just work.

The Lesson

Cross-platform bugs are the hardest to find and the easiest to ignore. Most developers work on Linux or macOS. Windows users suffer in silence. When someone reports a Windows bug, treat it as a gift. They are telling you about a whole category of problems your development environment will never reveal.

Story Three: The Ghost Lock That Haunted Production

The Project

The hold_lock context manager in cognee was supposed to provide safe, concurrent access to shared resources. It was simple. Acquire a lock. Do some work. Release the lock. What could go wrong?

The Discovery

Error reports were coming in about unhandled exceptions during cleanup. The stack traces pointed to the lock release statement. But the lock was being acquired successfully. How could releasing it fail?

The Investigation

I studied the code. The pattern was:

lock = acquire_lock()
try:
    yield lock
finally:
    lock.release()

Looks fine, right? Wrong.

If acquire_lock() failed and raised an exception, the finally block would still execute. But lock would be undefined or in an invalid state. The release would fail with its own exception, masking the original acquisition failure.

In high-concurrency environments, lock acquisition fails more often than you think. Timeouts, deadlocks, resource exhaustion. When that happens, the cleanup code makes things worse by throwing a second exception.

The Fix

Safely release lock in hold_lock context manager #7

aniruddhaadak80 posted on Jun 23, 2026

fixes #3294. This PR ensures that hold_lock only attempts to release the lock if it was successfully acquired. We now initialize the lock variable to None, attempt to acquire the lock inside the try block, and verify that the lock is not None in the finally block before calling release_lock.

View on GitHub

I restructured the pattern:

lock = None
try:
    lock = acquire_lock()
    yield lock
finally:
    if lock is not None:
        lock.release()

Now the release only happens if the lock was actually acquired. The original exception propagates cleanly. No ghost exceptions haunting the cleanup.

The Lesson

Cleanup code needs the same scrutiny as main logic. We tend to focus on the happy path. But software spends most of its life on unhappy paths. The finally block is where bugs go to breed. Never assume a resource was successfully acquired before trying to release it.

Story Four: The Tests That Lied About Windows

The Discovery

While contributing to openclaw, an agentic AI framework, I noticed something disturbing. The test suite had if (process.platform === 'win32') { return; } scattered throughout. Entire categories of tests were being skipped on Windows.

The Investigation

I asked a simple question. Why?

The comments said "Windows does not support symlinks." But that has not been true since Windows Vista. Windows has supported symlinks since 2007. It requires specific permissions, and directory junctions work even without admin rights. The tests were skipping Windows based on a decade-old assumption.

This meant bugs in symlink handling, path resolution, and file operations were going completely undetected on the most common desktop operating system in the world.

The Fix

test(browser): replace broad win32 skip with dynamic directory symlink check #90365

aniruddhaadak80 posted on Jun 04, 2026

Related: #90275

What Problem This Solves

The output-directories.test.ts test had a broad, unconditional skip for win32 platforms, meaning symlink rejection wasn't fully tested on Windows machines that do support symlinks/junctions. Additionally, the initial symlink capability probe was leaving uncleaned directories and failing linters.

Why This Change Was Made

To ensure that tests adapt dynamically to the environment's capabilities rather than blindly skipping based on OS. This makes the test suite more robust and accurate. The probe was updated to properly clean up after itself using fsSync.rmSync in a finally block and correctly evaluate if directory symlinks can be created on the given system without polluting the temp directory.

User Impact

No direct end-user impact. Improves test reliability and Windows developer experience by correctly evaluating symlink capabilities and ensuring no temporary directory pollution during testing.

Evidence

Tests run and pass successfully. All linters (including oxlint) pass on the updated probe.

✓  extension-browser  ../../extensions/browser/src/browser/output-directories.test.ts (2 tests) 270ms

 Test Files  1 passed (1)
      Tests  2 passed (2)

View on GitHub

test: make install-safe-path symlink tests compatible with Windows #90275

aniruddhaadak80 posted on Jun 04, 2026

Summary

Run the existing install-path symlink boundary tests on Windows when directory junctions are supported.
Use Windows junctions for directory links while preserving dir symlinks elsewhere.
Keep production install-path behavior unchanged.
Treat temporary-directory or cleanup failures in the capability probe as unsupported test environments instead of failing module import.

Linked context

No linked issue. This is a test portability improvement for existing install-path boundary coverage.

Real behavior proof

Behavior addressed: Three install-safe-path symlink boundary tests were unconditionally skipped on Windows.
Real environment tested: Native Windows Azure VM (Standard_D4ads_v6) through Crabbox.
Exact steps or command run after this patch: node scripts/run-vitest.mjs src/infra/install-safe-path.test.ts
Evidence after fix: Native Windows console output from Crabbox lease cbx_be4230e2069c, run run_0fb83e164185:

RUN  v4.1.8 C:/repo/openclaw

✓ infra src/infra/install-safe-path.test.ts (24 tests) 525ms

Test Files  1 passed (1)
Tests       24 passed (24)

Observed result after fix: The directory-junction cases executed successfully on native Windows instead of being skipped by platform.
What was not tested: No end-user install flow was exercised because the patch changes tests only.
Proof limitations or environment constraints: The tests still skip when the host cannot create directory links.
Before evidence: Current main uses it.runIf(process.platform !== "win32") for all three cases.

Tests and validation

node scripts/run-vitest.mjs src/infra/install-safe-path.test.ts
node scripts/run-oxlint.mjs src/infra/install-safe-path.test.ts
Native Windows Crabbox: 24/24 tests passed
Blacksmith Testbox tbx_01kv72nvfyz4fgpny8cyn48xfr: pnpm check:changed
.agents/skills/autoreview/scripts/autoreview --mode branch --base origin/main

Risk checklist

Did user-visible behavior change? No
Did config, environment, or migration behavior change? No
Did security, auth, secrets, network, or tool execution behavior change? No
Highest-risk area: Windows directory-link capability detection in the test harness.
Mitigation: Capability-gated execution plus direct native-Windows proof.

Current review state

Next action: Refresh CI on the rebased head and merge when required checks pass.
Addressed review comments: Temporary directory creation and cleanup are contained by the probe; module-level probing remains intentional because Vitest evaluates skipIf during test declaration.

View on GitHub

test: make qqbot symlinked media helper test robust on Windows #90223

aniruddhaadak80 posted on Jun 04, 2026

Replaces the hardcoded Windows skip in the QQ Bot file-utils test with a dynamic file-symlink capability check. If file symlinks are supported by the environment, the test executes. Otherwise, it skips gracefully while keeping coverage active on capable hosts.

What Problem This Solves

The symlinked local-media helper test should reject symlinked media paths when the runtime can create file symlinks, but it should not fail the suite on Windows or restricted environments where file symlink creation is unavailable. Gating the test on actual capability avoids false negatives while preserving the security regression coverage where the behavior can be exercised.

Evidence

Windows Vitest proof from the contributor: extensions/qqbot/src/engine/utils/file-utils.test.ts completed with 1 passed test file, 4 passed tests, and 1 skipped symlink test when file symlink creation was unavailable.
The follow-up repair commit cb7d5a162e24f7ec5be6985e97b2b74ae45b20f9 changes the probe to async fs.promises APIs and skips solely on !canCreateFileSymlinks, which addresses the stale Copilot comments about non-Windows restricted environments and synchronous import-time filesystem work.
Current PR CI is otherwise green; the remaining failed check was the external-PR body proof gate requiring these authored sections.

View on GitHub

Instead of skipping based on platform, I implemented dynamic capability checks. The tests now ask the operating system: "Can you create symlinks?" If yes, the test runs. If no, it skips with a clear explanation.

For directory operations, I used Windows junctions instead of symlinks. Junctions have been supported since Windows 2000 and do not require special privileges. For file symlinks, I check capability at runtime.

The Lesson

Assumptions are the root of all evil in software. Platform checks, version checks, feature detection. They all age poorly. Capability detection is the only approach that stays correct over time. Write code that asks what the system can do, not what you think it is.

Story Five: The AI That Could Not Tell Healthy from Sick

The Project

opensre is a site reliability engineering platform that uses LLMs to classify alerts and identify root causes. The promise is powerful. Feed it your monitoring data, and it tells you what is wrong.

The Discovery

The synthetic QA tests were failing. The LLM was classifying healthy alerts as noise. Specifically, scheduled maintenance checks and healthy status pings with severity information and normal state were being marked is_noise=True.

This was catastrophic. If the system filters out healthy signals as noise, it cannot establish a baseline. Without a baseline, every alert looks like an emergency. Engineers burn out. Pager fatigue sets in. Trust in the platform evaporates.

The Investigation

Using Antigravity with Google AI, I traced the classification pipeline. The problem was in the LLM extraction step. The prompt was not giving the model enough context to distinguish between "this alert is unimportant" and "this alert indicates a healthy state."

I needed to expand the training data. Specifically, the _build_database_directive() function needed to learn about:

Compositional faults where multiple issues mask each other
Red herrings in alert patterns
Dual fault symptoms versus single root causes
Missing storage metrics and how to infer them
RDS-specific scenarios like connection exhaustion

The Fix

fix(synthetic-qa): Identify healthy alerts correctly (#596) #618

aniruddhaadak80 posted on Apr 16, 2026

This PR fixes the 000-healthy synthetic-qa failure (Fixes: #596).

Cause:

The LLM extraction step was classifying 'healthy' and scheduled checks (which have severity 'info' and state 'normal') as is_noise=True.
Even if it bypassed noise extraction, the LLM was assuming it didn't need to gather investigation metrics because the alert explicitly said the database was normal, leading to an empty sequence of actions. This empty sequence caused the is_clearly_healthy function to loop infinitely because condition 4 requires at least one investigative operation.

Fix:

Noise Extraction: Updated app/nodes/extract_alert/extract.py prompt to explicitly state that informational states and health checks are NOT noise.
Planner Prompt Guidance: Updated app/nodes/plan_actions/build_prompt.py to ensure the agent MUST still query relevant monitoring platforms for verification when it identifies informational or healthy states.
Planner Code Guard: Added a code-level guard in app/nodes/plan_actions/node.py to fall back and force at least one verification action if the LLM returns an empty plan to prevent infinite insufficient_evidence loops.
Evidence Consistency: Fixed EKS evidence truthiness check in app/nodes/root_cause_diagnosis/evidence_checker.py to correctly evaluate via is not None.
Cleanup: Removed accidentally committed pr_body.md template.

View on GitHub

fix: Database directives for RDS QA testing #625

aniruddhaadak80 posted on Apr 17, 2026

Resolves #598 and #599 by supplying the agent with specific database directives that inform the RCA logic of standard scenarios like Connection Exhaustion and Free Storage exhaustion.

View on GitHub

fix: Database logic expansion for QA Edge Cases (Batch 2) #626

aniruddhaadak80 posted on Apr 17, 2026

_build_database_directive() has been expanded exponentially to train the AI to parse red herrings, distinguish between dual fault symptoms versus single root causes, infer missing Storage metrics organically, ignore healthy oscillating traffic metrics, and trace WAL replication lags adequately.

View on GitHub

fix: Database logic expansion for QA Edge Cases (Batch 3) #627

aniruddhaadak80 posted on Apr 17, 2026

Resolves #606, resolves #607, resolves #608, resolves #609, resolves #610. Expands the _build_database_directive() function to correctly train the LLM to identify Compositional Faults (treating simultaneous CPU and Storage constraints as independent sources while filtering out connection bounds), infer replication lag from bare WAL metrics despite missing Replica metrics, accurately ignore historical maintenance distractions via timestamps, identify stale autoscaling recovery, and distinguish VACUUM-driven Checkpoint Storms.

View on GitHub

I delivered the fix in three batched PRs. Each batch expanded the directive system with new training scenarios. The LLM learned to recognize healthy patterns, distinguish them from noise, and handle complex edge cases.

The key was batching. One massive PR would have been impossible to review. Three focused PRs made each change tractable and reviewable.

The Lesson

AI systems are only as good as their training data. When your AI misclassifies, do not blame the model. Blame the data. And then fix it. The directive expansion approach I used here is applicable to any AI system that makes classification decisions.

Story Six: The Float That Was Too Small to Exist

The Discovery

In OpenMythos, a research tool for linear time-invariant systems, I encountered a numerical bug that broke a mathematical guarantee.

The spectral radius ρ(A) must be less than 1 for system stability. The code computed it using exp(log_dt + log_A). After large gradient steps, log_dt + log_A could drop below -20. The exponential of -20 is approximately 2.06e-9.

Here is the problem. Float32 machine epsilon is approximately 1.19e-7. When you take the outer exponential of a number smaller than machine epsilon, the result rounds to exactly 1.0. Not approximately 1.0. Exactly 1.0.

This broke the ρ(A) < 1 guarantee. The system appeared stable when it was not. In research code, this kind of silent failure can invalidate months of work.

The Fix

Fix float32 underflow in LTIInjection.get_A() breaking ρ(A) < 1 guarantee #1

Copilot posted on Apr 22, 2026

After sufficiently large gradient steps, log_dt + log_A can be driven below -20, causing exp(-20) ≈ 2.06e-9 — smaller than float32 machine epsilon (≈ 1.19e-7) — so the outer exp(-2.06e-9) rounds to exactly 1.0, silently invalidating the spectral radius stability guarantee.

Change

LTIInjection.get_A(): tighten inner clamp lower bound from -20 → -14

At -14: exp(-14) ≈ 8.3e-7, which sits above the float32 ULP threshold at 1.0 (~5.96e-8), ensuring exp(-exp(x)) is always representable as strictly less than 1.0 in float32.

# Before — exp(-20) ≈ 2.06e-9 < float32_eps, outer exp rounds to 1.0
return torch.exp(-torch.exp((self.log_dt + self.log_A).clamp(-20, 20)))

# After — exp(-14) ≈ 8.3e-7 > ULP threshold, A < 1.0 holds in float32
return torch.exp(-torch.exp((self.log_dt + self.log_A).clamp(-14, 20)))

The upper bound (20) is unchanged; it guards against the opposite extreme (overflow → A ≈ 0), which is not problematic for stability.

View on GitHub

I implemented numerically stable computation using appropriate scaling and clamping. The fix prevents the intermediate result from falling below the representable range of float32.

The Lesson

Floating point arithmetic is a minefield. Every comparison, every exponentiation, every accumulation is a potential bug. When you are doing numerical computing, you need to think about precision at every step. The math might be correct on paper. The computer might still get it wrong.

The Tools That Made It Possible

I want to talk about the tools because they mattered enormously.

Antigravity Agentic IDE

This is not a regular code editor. It is an AI-native development environment that understands context across your entire codebase. I used it for:

Codebase exploration: Understanding repositories I had never seen before in minutes instead of hours
Bug diagnosis: Tracing error paths and identifying root causes with AI-assisted analysis
Fix generation: Drafting code changes that followed each project's conventions
Test verification: Running and interpreting test results across different environments

Google AI

The AI models behind Antigravity, powered by Google, were the engine that made everything else possible. They helped me find bugs I would have missed, understand codebases faster, and implement fixes with confidence.

What I Learned

After 373 merged pull requests, here are the lessons that stuck:

Security first. The most impactful fixes are often the simplest. Two lines of authorization logic can prevent a system takeover.
Question assumptions. Windows does support symlinks. The lock was not always acquired. The path was not always short enough. Every assumption is a potential bug.
Batch complex work. Three small PRs are better than one massive PR. Reviewers stay engaged. Mistakes get caught. Progress is visible.
Clean up responsibly. The finally block deserves the same attention as the try block. Resource cleanup is where silent failures happen.
Train your AI right. When AI systems misclassify, fix the training data. The model is not broken. Its education is incomplete.
Precision matters. Floating point arithmetic will betray you if you let it guard. Think about numerical stability in every calculation.

By the Numbers

Metric	Count
Total merged pull requests	373
Repositories contributed to	6+
Security vulnerabilities patched	2
Cross-platform compatibility fixes	5
Race conditions resolved	1
AI classification accuracy improvements	4
Numerical stability fixes	1
Test coverage restorations	3
UI/UX fixes	1

Closing Thoughts

This journey has been one of the most rewarding experiences of my development career. Every bug I fixed made someone's software a little better. Every PR I merged taught me something new. Every community I joined welcomed my contributions.

Open source is not just about code. It is about showing up, doing the work, and making things better for everyone who comes after you.

To the maintainers who reviewed my PRs: thank you for your patience and your feedback.

To the users who reported the bugs: thank you for taking the time to write clear issue descriptions.

To DEV, Sentry, and Google AI: thank you for creating this challenge and for supporting the open source community.

I am Aniruddha Adak, and I am just getting started.

Connect with me on LinkedIn, follow me on X, or explore my code on GitHub.

The Ultimate Prompt Library for Claude Fable 5 and GPT-5.6 Sol

ANIRUDDHA ADAK — Sat, 25 Jul 2026 05:40:00 +0000

80 plus tested, copy-paste ready prompts. Pick one, run it, ship it.

How to Use This Library
Game Prompts
Website Prompts
3D and Visual Prompts
Full-Stack App Prompts
Agentic and Automation Prompts
Design and UI Prompts
Physics and Simulation Prompts
Productivity and Tool Prompts
Fable 5 Specific Prompts
GPT-5.6 Sol Specific Prompts
Prompt Engineering Tips

How to Use This Library

Each prompt in this library follows the CLEAR framework:

Context -- Tell the AI what the project is and what already exists
Language -- Specify the programming language, framework, and libraries
Examples -- Reference existing designs or behaviors you want to replicate
Action -- State exactly what you want the AI to build, fix, or change
Result -- Describe the expected output format and file structure

Pro tip: Start broad, then narrow. Begin with the overall structure, then ask for specific sections or features in follow-up prompts. The AI already understands the context, so each iteration gets better than the last.

Game Prompts

1. Black Hole Simulation

Best for: Fable 5 (creative coding, physics visualization)

Prompt:

Build a real-time black hole lensing simulation in Three.js. Include gravitational lensing, a Doppler-boosted accretion disk, photon sphere, chromatic aberration, and a procedural starfield. Make it a single self-contained HTML file running at 60fps. Use no external image assets -- every piece of art and 3D object should be produced with math alone.

Result: 60fps single HTML file, one prompt, one shot.

Built by: @deveshcodes_

2. Mario Kart Racing Game

Best for: Fable 5 (complex game logic, multiple systems)

Prompt:

Build a Mario Kart 64 style racing game with 4 maps, character models, all three game modes, music, and full UI. Make it playable in the browser as a single HTML file. Include proper racing physics with drifting, item boxes with random power-ups, and lap timing. Use Canvas 2D or Three.js for rendering.

Result: Full game from a 2-sentence prompt, 15 minutes, 40 percent of Max 5x usage.

Built by: @kieradev

3. Terminal Minecraft in Rust

Best for: Fable 5 (systems programming, installable package)

Prompt:

Build a terminal UI version of Minecraft in Rust. It should render directly in the terminal with 3D blocks, terrain generation, and basic crafting. Make it installable via cargo. Include a day-night cycle, multiple biomes, different ores, and caves. The player should be able to place and break blocks using keyboard controls.

Result: cargo install termcraft-3d -- a fully installable Rust game.

Built by: @vikvang1

4. Sonic the Hedgehog Clone

Best for: GPT-5.6 Sol (fast physics, speed-based mechanics)

Prompt:

Build a playable Sonic the Hedgehog clone in a single HTML file. Include speed-based physics with momentum and acceleration, ring collection with a counter, enemy collision with stomp mechanics, and at least one full level with loops, springs, and ramps. Use Canvas 2D for rendering. Add a score system and a timer.

Result: Working prototype with physics that feel right. Sol produced the speed and momentum mechanics accurately.

5. Rocket League 3D

Best for: GPT-5.6 Sol (3D physics, self-checking)

Prompt:

Build a 3D Rocket League clone using Three.js. Include car physics with boost mechanics, ball physics with realistic bouncing and spin, goal scoring with a scoreboard, and a simple arena with walls. Make it playable with keyboard controls in a single HTML file. Add a reset button after each goal.

Result: Functional 3D game. Sol's visual self-checking feature helped iterate on ball physics until they felt right.

6. Dark Souls Combat

Best for: GPT-5.6 Sol (complex combat mechanics, AI)

Prompt:

Build a Dark Souls-inspired top-down action RPG in a single HTML file. Include stamina-based combat with light and heavy attacks, dodge rolling with i-frames, enemy AI with attack patterns and telegraphs, bonfire checkpoints, and a simple progression system with souls currency. Use Canvas 2D for rendering.

Result: Combat system with proper timing windows, enemy telegraphs, and risk-reward mechanics.

7. Minecraft Clone

Best for: Both models (block-based world, procedural generation)

Prompt:

Build a Minecraft clone in a single HTML file using Three.js. Include procedural terrain generation with Perlin noise, block placement and breaking with left and right click, a simple crafting system with a crafting grid, day-night cycle with lighting changes, and basic inventory with hotbar. Make it first-person with WASD controls and mouse look. Add at least 5 different block types.

Result: Functional block world with working terrain generation and building mechanics. Sol built it faster and cheaper. Fable 5 added more polish.

8. Finger-Tracking Dino Runner

Best for: Fable 5 (computer vision integration, MediaPipe)

Prompt:

Build a Dino runner game that uses finger tracking via the webcam as the input. The player raises their hand to jump over obstacles. Use MediaPipe for hand tracking and render the game in Canvas 2D. Include a score counter, increasing difficulty over time, and a game over screen with restart option. Make it a single HTML file.

Result: 914K tokens, 629 lines of code, built in 11-12 minutes.

Built by: @ai_for_success

9. GTA 2 Clone

Best for: Fable 5 (complex AI, multiple systems)

Prompt:

Build a top-down GTA 2 style game in a single HTML file. Include driving physics with drifting and handbrake turns, pedestrian AI that walks around and reacts to the player, shooting mechanics with different weapons and ammo, wanted levels with police response that escalates, and a city map with buildings, roads, and alleys. Use Canvas 2D. Add a minimap.

Result: Playable clone in about 2 hours, combining Fable 5 code generation with Tripo 3D assets.

Built by: @techhalla

10. Super Mario Platformer

Best for: Fable 5 (precise platformer physics, level design)

Prompt:

Build a Super Mario Bros style platformer in a single HTML file. Include proper jump physics with variable height based on button hold time, Goomba enemies with stomp mechanics and walking patterns, coin collection with a counter, power-ups including mushroom for size and fire flower for shooting, flag pole at the end of the level, and at least one full level with ground, pipes, and platforms. Use Canvas 2D.

Result: Polished platformer with mechanics that felt authentic to the original. Around 2 million tokens used.

Built by: @pankajkumar_dev

11. Snake Clone

Best for: Fable 5 (simple but polished, self-aware mechanics)

Prompt:

Build a Snake clone in a single HTML file. Include a self-aware mechanic where unusual events occur as the snake grows longer -- for example, the snake might change color, the background might shift, or special power-ups might appear. Use Canvas 2D. Add a score counter, high score persistence using localStorage, and increasing speed as the snake grows.

Result: A Snake game with personality. Built by Ethan Mollick in one prompt.

Built by: Ethan Mollick

12. Balatro-Style Card Game

Best for: Fable 5 (card game logic, scoring systems)

Prompt:

Build a Balatro-style coin-flip card game in a single HTML file. Include a deck of cards with suits and values, a scoring system based on poker hands, shop mechanics to buy upgrades between rounds, and increasing difficulty. Use Canvas 2D or CSS for rendering. Make it visually polished with card animations.

Result: A playable card game with strategic depth. Built by Ethan Mollick in one prompt.

Built by: Ethan Mollick

13. Backrooms Horror Escape

Best for: Fable 5 (atmospheric design, audio integration)

Prompt:

Build a playable browser-based Backrooms horror escape game in a single HTML file. Include eight pages to find, unsettling ambient audio, a flashlight mechanic with limited battery, and a sanity meter that decreases in dark areas. Use Canvas 2D or Three.js for rendering. Add jump scares and a timer.

Result: A genuinely unsettling game. The builder stopped playtesting at 2am because they did not want to keep going alone.

14. Subway Surfers Clone

Best for: Fable 5 (endless runner, 3D assets)

Prompt:

Build a Subway Surfers style endless runner game in a single HTML file. Include a character that runs automatically, swipe or arrow key controls to dodge obstacles, collect coins, and power-ups like jetpacks and magnets. Add a score multiplier system and increasing speed over time. Use Three.js for 3D rendering or Canvas 2D for a simpler version.

Result: A full game built in about one hour inside Rork, including game art and 3D models.

15. Dusk Drive (Low-Poly Driving Game)

Best for: Fable 5 (atmospheric visuals, low-poly art)

Prompt:

Build a low-poly driving game called Dusk Drive in a single HTML file. Include a car that drives through an aurora snow drifting scene, with low-poly trees and mountains in the background. Add a speedometer, a drift scoring system, and a day-night cycle. Use Three.js for rendering. Make it visually atmospheric with minimal human editing needed.

Result: Complete driving game from one prompt, zero human editing between idea and playable version.

Built by: @VincentLogic

16. Namma Metro Simulator

Best for: Fable 5 (location-specific simulation, public transit)

Prompt:

Build a Namma Metro simulator in a single HTML file. Include a map of the Bengaluru Metro lines, stations that players can click to travel between, a fare calculation system based on distance, and a train schedule display. Add a first-person view from inside the train with station announcements. Use Canvas 2D or Three.js.

Result: A location-specific transit simulator built while riding the actual metro.

Built by: @anilbpai

17. Three.js Hole Game

Best for: Fable 5 (3D physics, casual game)

Prompt:

Build a 3D HOLE IT style game using Three.js. The player controls a hole that grows by swallowing objects. Include physics for object falling, a level system with increasing difficulty and larger objects, and a scoring system based on objects swallowed. Make it a single HTML file with keyboard controls.

Result: An entire 3D browser game prototype from one compact request.

Built by: @thebuggeddev

18. DataEmpire Web Analytics Game

Best for: Fable 5 (data visualization, gamification)

Prompt:

Turn raw website analytics data into a replayable game. Map visitors and milestones onto game entities -- for example, visitors become enemies, page views become collectibles, and conversion goals become boss battles. Use Canvas 2D or Three.js. Make it a single HTML file with a dashboard showing real metrics alongside the game.

Result: A creative way to visualize analytics data through gameplay.

19. SimRefinery Recreation

Best for: Fable 5 (complex simulation, historical recreation)

Prompt:

Rebuild SimRefinery, a 1990s business simulation game for Chevron, using surviving screenshots and documentation. Include an interactive learning mode, refinery processes like distillation and cracking, and a scoring system based on efficiency and profit. Make it a single HTML file with educational value.

Result: A fully playable version of a lost game, rebuilt from screenshots and docs.

Built by: Ethan Mollick

20. Hogwarts Castle Explorer

Best for: Fable 5 (large 3D environment, exploration)

Prompt:

Build a full explorable Hogwarts castle in Three.js. Include classrooms, the Great Hall, the Quidditch pitch, moving staircases, and secret passages. Add ambient sounds, a day-night cycle, and interactive objects. Make it a single HTML file with first-person controls and a map.

Result: An entire Hogwarts castle, one-shot by Fable 5.

Built by: Matt Shumer

Website Prompts

21. Awwward-Winning Portfolio

Best for: Fable 5 (premium design, animations)

Prompt:

Design an Awwward-winning portfolio website for a creative agency. Include a cinematic hero section with 3D parallax and gradient text animation, smooth scroll animations using GSAP or CSS, a project showcase with hover effects and case study previews, client testimonials with a carousel, and a contact form with validation. Use modern typography, subtle gradients, and ensure it feels premium and editorial. Single HTML file with embedded CSS and JS.

Result: A website that could genuinely compete in design awards.

22. 3D Interactive Space Website

Best for: Fable 5 (Three.js, immersive experience)

Prompt:

Build a 3D interactive space exploration website. Include a navigable solar system with realistic planet textures generated procedurally, orbital mechanics with accurate relative speeds, click-to-explore planet details with facts and figures, a starfield background with parallax scrolling, and smooth camera transitions between planets. Use Three.js and make it a single HTML file.

Result: A fully navigable 3D solar system. Clicking planets shows detailed information with smooth camera animations.

23. WordPress Block Theme from Screenshot

Best for: Fable 5 (CMS integration, theme development)

Prompt:

I have a screenshot of a website and its URL. Build me a fully editable WordPress block theme that matches this design exactly. Use native WordPress patterns and blocks. Make it responsive, accessible, and follow WordPress coding standards. Include custom block styles if needed. Output the theme files in a structured folder.

Result: One shot. Fully editable. Native WordPress patterns. The builder's reaction: "Yeah, this feels next level."

Built by: Jamie Marsland (Automattic)

24. macOS-Style Web OS

Best for: Fable 5 (complex UI, multiple apps)

Prompt:

Build a complete macOS-style web OS in a single HTML file. Include a macOS menu bar and dock, draggable and resizable app windows, a functional file explorer with folders and files, a working terminal that accepts basic commands, a browser mockup, SVG desktop icons and notifications, a settings app with themes and a boot screen, a fully functional sound player with real audio synthesis and no external files, and a playable Minecraft clone as one of the desktop apps. Use embedded CSS and JS.

Result: All generated in one pass with almost no corrections. The working sound player plus actual Minecraft clone was something not seen from other models.

Built by: @intheworldofai

25. 80-Page Agency Website

Best for: Fable 5 (large-scale content, consistency)

Prompt:

Build a modern tech stack agency website with 80 pages. Include a hero section with animated headline, features section with icons, case studies with before/after metrics, blog articles with SEO and AEO optimization, skills showcase with progress bars, and a playbook section with downloadable resources. Make it responsive, fast, and follow modern best practices. Use a clean, professional design with consistent branding across all pages.

Result: 80 pages ready to ship over a weekend. The builder said they would have charged $50k for that as an agency.

Built by: @JJEnglert

26. Marketing Homepage (Head-to-Head)

Best for: Both models (comparison test)

Prompt:

Build the marketing homepage for a fictional company, Northwind Logistics, a freight-tracking platform. It should include a single self-contained HTML file with a dynamic hero section with animated gradient, a nav bar with logo and links, features section with three value propositions, social proof with customer logos and testimonials, a pricing or CTA section, and a footer with links and newsletter signup. Use modern CSS with Tailwind-style utility classes.

Result comparison:

Metric	Fable 5	GPT-5.6 Sol
Time	126.7 seconds	175.9 seconds
Output tokens	12,882	15,913
Cost	$0.6467	$0.3587
Completeness	Full pricing table	No pricing shown
Design	Dark navy, animated dots	Lighter, mint-accented

Tested by: Merge.dev

27. SaaS Hero Section with Animated Gradient

Best for: GPT-5.6 Sol (fast UI, structured output)

Prompt:

Build a hero section for a SaaS landing page using Next.js 14 App Router and Tailwind CSS. Requirements: large headline with a gradient text effect (blue to purple) that subtly animates, subheadline below it (16-20 words max) in muted gray, two CTA buttons side by side: primary "Start Free" (filled, blue) and secondary "Watch Demo" (outlined), a hero image placeholder on the right side (use a rounded div with a subtle shadow as placeholder), fully responsive: stacked layout on mobile, side-by-side on desktop, add a subtle fade-in animation on page load using CSS only (no JS animation libraries). Output a single React component file with TypeScript.

Result: A complete hero component with Tailwind classes, responsive grid, and CSS keyframe animations -- ready to drop into your app.

28. Feature Grid with Icons

Best for: GPT-5.6 Sol (component-based, structured)

Prompt:

Create a features section for a SaaS marketing site. Use Next.js and Tailwind CSS. Display 6 features in a 3-column grid (2 columns on tablet, 1 on mobile). Each feature card has: an icon placeholder (use a colored circle with an emoji), a bold title, and a 2-sentence description. Cards should have a subtle hover effect (slight lift with shadow). Use these features: AI Code Generation, Visual App Builder, One-Click Deploy, Team Collaboration, Custom Domains, Built-in Analytics. Color scheme: dark background (#0a0a0a), white text, accent color #6366f1 for icon backgrounds. TypeScript, no external icon libraries. Output a single component file.

Result: A polished feature grid component with responsive columns and hover animations.

29. Pricing Page with Toggle

Best for: GPT-5.6 Sol (interactive components, state management)

Prompt:

Build a responsive pricing page with three tiers: Free ($0 per month), Pro ($29 per month), and Enterprise (custom pricing). Include a monthly-slash-annual toggle where annual shows a 20 percent discount. Each tier should list 5-6 features with checkmarks. Use Next.js 14 App Router and Tailwind CSS. Add a FAQ section below the pricing. Output a single page.tsx file I can drop into my app-slash-pricing directory. Use Tailwind for all styling. No external UI libraries.

Result: A complete, usable pricing component with state-managed toggle.

30. Website from Screenshots Only

Best for: Fable 5 (visual understanding, recreation)

Prompt:

I have screenshots of a SaaS landing page. Build the matching app with working functionality. Do not describe architecture -- just hand you the picture of the result I want. Include all sections visible in the screenshots: hero, features, pricing, testimonials, and footer. Make it responsive and pixel-perfect. Output as a single HTML file or structured project files.

Result: A creator fed Fable only screenshots of a SaaS landing page and it built the matching app. You do not have to describe architecture you do not understand.

3D and Visual Prompts

31. Swiss Lever Watch Mechanism

Best for: Fable 5 (mechanical simulation, physics verification)

Prompt:

Build a Swiss lever watch movement in Three.js. Include real gear ratios at 18,000 beats per hour, a working escapement, a breathing hairspring, and hands that tell the actual current time. Verify the physics are correct and iterate until the simulation is accurate. Use no external assets. Make it a single HTML file.

Result: It verified its own work with vision, in a loop, until done. The hands actually told the correct time.

Built by: @quanghuynt14

32. Friends Apartment 3D Scene

Best for: Fable 5 (scene recreation, lighting)

Prompt:

In Three.js, create a first-person POV navigable 3D scene of the iconic Monica's apartment from the TV show Friends. Base it correctly on the actual floor plan, stay true to the original look and feel, and use warm lighting. Include furniture, decorations, and the famous purple door. Make it a single HTML file with WASD controls and mouse look.

Result: "This is by far THE BEST I have seen on this test." The single HTML file cost $12 but the result was stunning.

Built by: @scottstts

33. Solar System Simulation

Best for: Fable 5 (physics derivation, prediction)

Prompt:

Build a solar system simulation by deriving planetary orbital motion from the basic principles of physics. Use Newton's law of gravitation and Kepler's laws to calculate orbits. Then use this simulation to predict upcoming solar eclipses. Make it interactive with Three.js in a single HTML file. Include all planets with relative sizes and distances, and allow the user to speed up or slow down time.

Result: After a few rounds of back-and-forth, the simulation was complete and accurate. It was incredibly fun to explore.

Built by: @tetumemo

34. 3D Business City Dashboard

Best for: Fable 5 (data visualization, creative mapping)

Prompt:

Turn my business workflow into a live 3D city dashboard. Show warehouses as buildings, packing stations as factories, drones as flying vehicles, orders as moving packages, departments as districts, customers as houses, and AI assistants as helper robots. Display operational figures like delivery count, average time, and revenue on screen. Use Three.js in a single HTML file. Make it update in real-time with simulated data.

Result: A client-facing alternative to static slides. Operational data visualized as a living city.

Built by: @noisyb0y1

35. V8 Engine CAD Model

Best for: Fable 5 (mechanical engineering, CAD)

Prompt:

Build a fully working V8 engine CAD model in Three.js. Include all moving parts: pistons, crankshaft, camshaft, valves, and timing chain. Animate the engine running at different RPMs. Allow the user to explode the view to see internal components. Make it a single HTML file with no external assets.

Result: A fully working CAD model in under ten minutes.

Built by: Aaron

36. QDD Actuator with Collision Testing

Best for: Fable 5 (robotics, simulation validation)

Prompt:

Design a quasi-direct-drive actuator in Three.js. Include the gearbox, motor, and output shaft. Animate the gearbox and run collision inspection as part of your own validation loop. Show torque curves and efficiency metrics. Make it a single HTML file with interactive controls for speed and load.

Result: Designed, animated, and collision-tested in about 30 minutes and 400,000 tokens.

Built by: Jake

37. Infinite Explorable Universe

Best for: Fable 5 (procedural generation, asset creation)

Prompt:

Build an infinite explorable universe with characters and lore. Connect to image-generation and image-to-3D APIs to create every asset and sound from scratch. Include procedurally generated planets, alien species with backstories, and a quest system. Use Three.js for rendering. Build it in three prompts over two hours on max effort.

Result: An infinite universe with every asset and sound made from scratch, in three prompts over two hours.

Built by: Anshu

38. Wall Calendar Dashboard for OLED

Best for: Fable 5 (IoT integration, real-time data)

Prompt:

Build a wall-calendar dashboard for a 77-inch OLED display. Include a household calendar with events, weather widget, news ticker, and app controls for Sonos and Spotify. Make it visually clean with large fonts readable from across the room. Use a dark theme suitable for OLED. Output as a single HTML file with auto-refresh.

Result: A household dashboard plus apps to control Sonos and Spotify, then a portfolio site on Ghost.

Built by: u-slash-orangejulius

Full-Stack App Prompts

39. Cafe Ordering App

Best for: Both models (comparison test)

Prompt:

Build a full-stack cafe ordering app. Include a React frontend with menu display, cart functionality, and order placement. Include a Node.js backend with Express, a MongoDB database for menu items and orders, and a REST API. Add user authentication with JWT, an admin panel for menu management, and order status tracking. Deploy it as a single project with clear setup instructions in a README.

Result: Both produced working apps. Sol was nearly 9x cheaper.

Model	Cost
GPT-5.6 Sol	$7
Claude Fable 5	$62

40. Gamified Homework Tracker

Best for: GPT-5.6 Sol (gamification, kid-friendly UI)

Prompt:

Build a gamified homework tracking app for kids. Include a React frontend with a character avatar that levels up, XP points for completing assignments, streak counters, a parent dashboard with progress reports, and fun animations. Use a Node.js backend with user authentication and data persistence. Make it engaging and kid-friendly with bright colors and simple language. Add a reward system where kids earn badges.

Result: A complete app with character progression, XP systems, and parent oversight. Built in one shot with Codex.

Built by: Lenny's Newsletter team

41. Space-Themed Onboarding Game

Best for: GPT-5.6 Sol (interactive tutorial, product education)

Prompt:

Build a space-themed onboarding game for a SaaS product. Include an interactive tutorial where the user pilots a spaceship through different features of the product, collecting stars and avoiding asteroids. Each level teaches a different feature. Use React and Canvas 2D. Add a progress bar and completion rewards. Make it a single-page app.

Result: An engaging onboarding experience that teaches product features through gameplay.

42. Spawn 5.0 Game Engine

Best for: Fable 5 (long-horizon engineering, complex systems)

Prompt:

Build a game engine from scratch called Mantle. It should have physics rivaling Rapier, clustered froxel lighting supporting 1,000 plus dynamic lights, realtime diffuse global illumination on WebGPU, million-particle GPU VFX with shader architecture beyond Unreal and Unity, and MMO-scale netcode. Also build an alpha native iOS app that uses this engine. Work across 1,000 plus prompts if needed.

Result: All of it took about a week. All of it runs on mobile. The builder's job shifted from architecture to judging taste.

Built by: @jsnnsa

43. iOS Calorie Tracker

Best for: Fable 5 (native mobile, delightful UX)

Prompt:

Build an extremely delightful calorie tracker for iOS. Include a food search with autocomplete, a daily log with meal categories, progress charts with animations, and a water tracker. Make the UI feel native with smooth transitions and haptic feedback. Use React Native or Swift. Include a widget for the home screen.

Result: A working native app from a single prompt. The interesting signal is native mobile, not just web, coming out of one instruction.

Built by: Anshu

44. Programmatic Clip Factory

Best for: Fable 5 (long-running automation, multi-tool integration)

Prompt:

Build a programmatic clip factory that automates my content pipeline. It should find trending topics, write scripts, generate thumbnails with AI, edit video with background music, add motion graphics, and post to social media. Wire together HeyGen for video generation, ElevenLabs for voiceover, Cloudflare Workers for hosting, and a VPS for processing. Build a webhook system to monitor renders and handle errors. Run autonomously for long stretches.

Result: The pipeline ran for long stretches on its own and even built itself a webhook system to monitor renders.

Built by: @JJEnglert

45. CloudWatch Log Triage Agent

Best for: Fable 5 (large data analysis, infrastructure)

Prompt:

Analyze these CloudWatch logs and infer the system architecture. Then identify specific faults, errors, and performance issues. Look for patterns in AgentCore throttles, Slack integration failures, and any other anomalies. Process up to 80,000 lines of logs in one run. Provide a detailed report with fixes and priority levels.

Result: 53 steps taken, 32k active tokens spent. The agent flagged issues the human team had missed, including subtle architectural problems.

Built by: @diblacksmith

46. World Cup Predictor

Best for: Both models (multi-model orchestration, research)

Prompt:

Build a World Cup predictor that researches live news, injuries, and yellow-card context. Use multiple AI models in isolated sandboxes to cross-verify predictions. Display results in a public app with confidence scores. Include team form, player availability, and historical match data. Update automatically as new information comes in.

Result: A multi-model research and orchestration stack rather than a standalone chat demo. Used Claude Fable 5, GPT-5.5, and Gemini.

Built by: Upstash

47. Browser Automation (LinkedIn)

Best for: GPT-5.6 Sol (Chrome automation, high volume)

Prompt:

Automate my LinkedIn replies using Chrome. Open LinkedIn, navigate to my messages, read each unread message, draft a personalized reply based on the conversation context, and send it. Handle 500 replies automatically. Use browser automation with proper error handling and rate limiting. Do this while I do nothing -- fully autonomous.

Result: The single most-loved use case. The user did literally nothing while 500 replies were handled.

Built by: Lenny's Newsletter

Design and UI Prompts

48. Beautiful One-Shot Landing Page

Best for: Fable 5 (designer-quality first draft)

Prompt:

Build a beautiful landing page for a productivity app. Include a hero section with animated gradient text, a features section with icon cards, a testimonials carousel, and a pricing section. Make it visually polished with smooth animations, modern typography, and a cohesive color scheme. Single HTML file with embedded CSS and JS. No external design assets.

Result: A polished landing page that looks shippable rather than like a placeholder.

Built by: Alex Prokhorov

49. Website About Itself (Creative Freedom)

Best for: Fable 5 (creative autonomy, aesthetic judgment)

Prompt:

Build a website about yourself. You have complete creative freedom -- choose the topic, style, colors, and layout. Make it wild and unexpected. Show what you can do when given full artistic control. Single HTML file with embedded CSS and JS.

Result: The model made an aesthetic call with no human art direction, and the result held up.

Built by: Aurelien

50. Ecommerce Email Mockup

Best for: Fable 5 (brand design, email marketing)

Prompt:

Design a complete ecommerce email mockup for a fashion brand. Include exact sections: hero image, product grid with 4 items, a limited-time offer banner, customer reviews, and a footer with social links. Specify visual direction: minimal, high-contrast, serif headings with sans-serif body text. Include product requirements and constraints. Output as a single HTML file suitable for email clients.

Result: A complete creative brief executed in one prompt.

51. McKinsey-Style Report

Best for: Fable 5 (document generation, data visualization)

Prompt:

Write a McKinsey-style detailed report on Bitcoin as an asset class and blockchain technology. Include an executive summary, market analysis with data charts, an investment thesis, risk analysis with probability-weighted scenarios, and a conclusion with recommendations. Generate charts and visuals as needed. Output as a structured document with clear headings and professional formatting.

Result: A 19-page document with data, charts, an investment thesis, and risk analysis.

Built by: @smtgpt

Physics and Simulation Prompts

52. Chaotic Double Pendulum

Best for: Fable 5 (real physics, no libraries)

Prompt:

Build a self-contained HTML5 simulation of a chaotic double pendulum with real physics and no external libraries. Include adjustable parameters for mass, length, and initial angle. Show the trajectory trail and energy graph. Make it interactive with sliders. Single HTML file.

Result: Part of a physics simulation comparison. Fable 5 produced more accurate and stable physics.

Tested by: @atomic_chat_hq

53. Galton Board

Best for: Fable 5 (probability, statistics visualization)

Prompt:

Build a self-contained HTML5 simulation of a Galton board (bean machine) with real physics and no external libraries. Show the pegs, falling balls, and bin distribution at the bottom. Include adjustable parameters for ball count and peg spacing. Display the resulting normal distribution curve. Single HTML file.

Result: Part of a physics simulation comparison. Fable 5: $3.35 on 68.7k tokens, 14m 47s. Opus 4.8: $0.93 on 38.9k tokens, 8m 10s.

Tested by: @atomic_chat_hq

54. Water in Spinning Drum (WCSPH)

Best for: Fable 5 (fluid dynamics, particle simulation)

Prompt:

Build a self-contained HTML5 simulation of water in a spinning drum using WCSPH (Weakly Compressible Smoothed Particle Hydrodynamics) with real physics and no external libraries. Show the fluid body, spinning drum walls, and particle behavior. Include adjustable parameters for spin speed and viscosity. Single HTML file.

Result: Fable 5 produced a much more solid and continuous body of water. Opus left larger gaps near the walls and scattered particles.

Tested by: @atomic_chat_hq

55. Isochronic Travel Map

Best for: Fable 5 (real-world data, multi-agent research)

Prompt:

Build an isochronic travel map showing real travel times between major cities. Research over 2,200 specific flights, rail schedules from the TGV to the Shinkansen, and road speeds per country from academic papers. Use multiple sub-agents to research in parallel while coding. Display results as an interactive map with color-coded travel time zones. Single HTML file.

Result: Fable autonomously launched multiple sub-agents to research while coding in parallel. The model worked for 9.5 hours on this task.

Built by: Ethan Mollick

Productivity and Tool Prompts

56. Meeting Notes Action Plan

Best for: Fable 5 (document analysis, task extraction)

Prompt:

Review a week's worth of meeting notes and generate an action plan. Extract action items, assign owners based on context, set deadlines, and identify dependencies. Format as a structured markdown document with a summary table and detailed sections per meeting. Include a priority matrix (urgent vs important).

Result: A comprehensive action plan extracted from unstructured meeting notes.

57. Customer Email Analysis

Best for: Fable 5 (pattern recognition, sentiment analysis)

Prompt:

Analyze customer emails to identify recurring complaints, feature requests, and praise. Categorize by theme, sentiment, and urgency. Generate a summary report with top 5 issues, suggested responses, and a product improvement roadmap. Include example quotes (anonymized) for each category.

Result: Actionable insights from unstructured customer feedback.

58. Writing Editor Pre-Publish

Best for: Fable 5 (content review, quality assurance)

Prompt:

Act as my writing editor. Review every article before I publish it. Check for clarity, grammar, tone consistency, factual accuracy, and SEO optimization. Suggest headline alternatives, meta descriptions, and internal linking opportunities. Flag any claims that need citation. Output a structured review with severity levels.

Result: A pre-publish checklist that catches issues before they go live.

59. Large Pull Request Review

Best for: Fable 5 (code review, correctness verification)

Prompt:

Review this large pull request for correctness, false positives, real bugs, and polish issues. Check for logic errors, off-by-one mistakes, missing error handling, inefficient loops, security vulnerabilities, and architectural concerns. Do not just list issues -- explain why each matters and suggest fixes. Output a structured review with priority levels.

Result: Fable 5 is the first model that was so methodical and precise: taking measurements, adding logs, and verifying that it truly fixed the issue before declaring victory.

Tested by: @bcherny

60. Infrastructure Outage Diagnosis

Best for: Fable 5 (log analysis, root cause analysis)

Prompt:

Diagnose this infrastructure outage. I have logs, database errors, and image digests. Identify the root cause, trace the failure path, and prepare a fix. Include a timeline of events, affected services, and a prevention plan. Output a post-mortem document with actionable items.

Result: Fable 5 diagnosed the outage and prepared the fix from infrastructure clues.

Fable 5 Specific Prompts

61. Audit Your Own Instructions

Best for: Fable 5 (self-improvement, knowledge layer cleanup)

Prompt:

Read your own instruction files (CLAUDE.md, skills, rules, memory files) end to end. 1. Where do they contradict each other? Quote both sides. 2. Which rules exist to manage a weaker model: guardrails for failure modes you do not have, recipes for things you no longer need spelled out, hardcoded facts that have drifted? List them with file:line. 3. Which rules teach by bad example: documents that violate the patterns they prescribe? 4. What would you delete? What would you keep exactly as is, and why? Do not fix anything yet. Report first. I decide what gets cut.

Result: The audit is the model's judgment. The deletions are yours. This is the first prompt to run before giving any new model real work.

Recommended by: @charliejhills

62. Set Goal and Verify with Workflow

Best for: Fable 5 (Claude Code, autonomous execution)

Prompt:

Set a goal to implement the spec fully, then use a workflow to verify each part of the plan, and prepare a report on what was implemented and if anything differed. Use the slash-goal feature in Claude Code to keep working until the spec is fully implemented. Use Workflows to parallelize and verify your own work.

Result: A fundamental shift in how work is done: from verifying if Claude is doing the work correctly, to verifying if Claude is doing the right work.

Recommended by: @oikon48 (Claude Code team)

63. Interview Before Coding

Best for: Fable 5 (thought partner, requirements gathering)

Prompt:

Before we start coding, interview me about the project. Ask me about the audience, the goals, the constraints, and what success looks like. Provide background and context rather than only constraints. For example, instead of saying "keep it simple" or "do not overbuild," say: "This is an experimental feature and is likely to be removed in a month, so design it so it is easy to throw away later." Treat me as a thinking partner, not just a task giver.

Result: Better outcomes when Claude understands the intent behind a request before building.

Recommended by: @oikon48 (Claude Code team)

64. Prevent Over-Planning

Best for: Fable 5 (behavioral correction, efficiency)

Prompt:

When you have enough information to act, act. Do not re-derive facts already established in the conversation, re-litigate a decision the user has already made, or narrate options you will not pursue in user-facing messages. If you are weighing a choice, give a recommendation, not an exhaustive survey.

Result: Prevents Fable 5 from surveying options it will not pursue, a common behavior at higher effort settings.