24 Replit Agent Prompts for Debugging & Refactoring (2026)

I'm getting this error. Find the root cause before changing anything.

Error (exact text):
[paste the full error message / console output here]

What I was doing when it happened: [e.g. clicking "Save" on the profile page].
Expected: [what should happen]. Actual: [what happens instead].

First, investigate and tell me in 2-3 sentences what the root cause is and which file/line it's in. Then propose the smallest fix. Don't refactor anything unrelated. After you fix it, reproduce my steps in the browser to confirm it's resolved, and create a checkpoint.

The app crashes with the stack trace below. Trace it to the originating call, not just the line that threw.

Stack trace:
[paste full stack trace]

Trigger: [what action causes it]. It happens [always / sometimes when ...].

Walk the trace back to where the bad value or null actually comes from, explain it, then fix the origin — add the guard/validation where the data enters, not a try/catch that hides it. Keep the change scoped to the files involved. Test the trigger action afterward and create a checkpoint.

There's an intermittent bug I can't reliably reproduce: [describe what goes wrong, e.g. "sometimes the cart total is wrong after removing an item"].

It seems to happen when [any pattern you've noticed]. Expected: [X]. Actual: [Y].

First, try to reproduce it in the browser by repeating the flow several times, including edge cases (empty state, fast repeated clicks, back button). Once you can trigger it, tell me the condition that causes it before fixing. Fix the root cause, add a small test that covers that condition, and create a checkpoint. Don't change unrelated behavior.

A user flow is broken. Fix it, then test the whole flow yourself.

Flow: [e.g. sign up → verify email → land on dashboard].
Steps to reproduce: 1) [...] 2) [...] 3) [...]
Expected: [what should happen at each step].
Actual: [what actually happens, and where it breaks].

Investigate the flow end to end and tell me where and why it breaks before editing. Fix only what's needed to make the flow work as described. Then run through all the steps in the browser to confirm each one, and create a checkpoint.

The [name] form doesn't submit. When I fill it in and click [Submit], [nothing happens / it shows no confirmation / the data isn't saved].

Expected: on submit, validate the fields, save to the database, show a success message, and clear the form. Actual: [describe].

Check the whole chain: client-side validation, the submit handler, the API/route, and the database write. Tell me which link is failing before you fix it. Make validation errors visible to the user instead of failing silently. Test a real submission end to end and create a checkpoint.

The layout breaks on [mobile / a narrow screen / tablet]. Problem: [e.g. "the nav overlaps the hero and a button is cut off"] on screens around [375px] wide. It looks fine on desktop.

Expected: [describe the correct responsive behavior]. Actual: [describe the breakage].

Reproduce it at that viewport in the browser, find the CSS/layout rule causing it, and fix it without changing the desktop layout. Check the fix at 375px, 768px, and 1280px. Keep changes scoped to the affected components. Create a checkpoint.

My deployment is failing. Here is the deploy/build log:

[paste the full deployment log or the error from the Deployments pane]

Deployment type: [Autoscale / Reserved VM / Static / Scheduled].

Diagnose why the deploy fails — build error, missing dependency, wrong start/build command, missing environment variable, or port/config issue. Tell me the specific cause before changing anything. Fix the configuration and code as needed so it deploys successfully, then confirm the build passes. Don't change app features — only what's required to deploy. Create a checkpoint.

The app works in the workspace but is broken on the deployed URL: [describe what's different, e.g. "images 404" / "API calls fail" / "blank page"].

Deployed URL behavior: [what you see]. Expected: same as the workspace.

Investigate the usual dev-vs-prod causes: hardcoded localhost URLs, missing production Secrets, relative vs absolute paths, build output not served, or CORS. Tell me the specific difference before fixing. Fix it so production matches the workspace, and don't touch working features. After fixing, verify against the deployed URL and create a checkpoint.

I have a dependency problem: [paste the error, e.g. a version-conflict / "module not found" / peer-dependency warning].

Figure out which packages conflict and why. Explain the conflict and your proposed resolution before changing anything — I want to know if you're upgrading, downgrading, or pinning a version and what could break. Prefer the smallest, most stable set of version changes. After updating, reinstall, run the app, and confirm nothing regressed. Create a checkpoint so I can roll back if a version bump causes issues.

Something that depends on an API key or config isn't working: [describe, e.g. "the OpenAI call returns 401" / "Stripe key is undefined"].

The keys should be read from Replit Secrets, not hardcoded. Check that the code reads the right Secret names, that they're referenced correctly, and that nothing is committed in plain text. Tell me exactly which Secret names the app expects so I can confirm they're set. Add a clear startup check that fails with a readable message if a required Secret is missing. Don't print secret values in logs. Create a checkpoint.

The [page/endpoint, e.g. "dashboard"] is slow — it takes about [X] seconds to load. It should feel fast (under [1] second).

Profile what's slow before changing anything: is it a slow database query, too many queries, a large payload, or blocking work on the main thread? Tell me the specific bottleneck and the numbers you measured. Then fix the biggest one first — add an index, batch/cache the query, paginate, or defer work — without changing what the page shows. Re-measure and report the before/after. Keep the change scoped and create a checkpoint.

I think the [list/page, e.g. "orders list"] is running an N+1 query — it makes one query per row instead of one query for all rows, and it gets slower as data grows.

Confirm whether that's happening by inspecting the data-access code and the query count for that view. Tell me what you found before editing. If it's N+1, fix it by eager-loading / joining / batching so it's a small constant number of queries. Don't change the data shown or the API contract. Verify the query count drops and the page renders identically, then create a checkpoint.

Initial page load feels heavy. Reduce the front-end bundle size and improve first load without changing how the app looks or behaves.

First, report the current bundle size and the largest contributors. Then apply safe wins: code-split routes, lazy-load heavy components, drop or replace oversized dependencies, and ensure images are appropriately sized. Explain each change and its impact. Don't remove any feature. Re-measure and give me the before/after bundle size, then create a checkpoint.

Refactor [file path] to be cleaner and easier to maintain, without changing its behavior.

Goals: extract repeated logic into well-named functions, improve names, remove dead code, and add short comments only where the intent isn't obvious. Do NOT change the file's public interface (exports, function signatures, props) or its behavior — this is a pure refactor. Tell me the changes you plan to make first. After refactoring, run the app and confirm the affected feature works exactly as before. Create a checkpoint.

Run this in Plan Mode. [file path] has grown too large ([~N] lines) and mixes several concerns. Split it into focused modules without changing behavior.

Propose a plan first: how you'll group the code (e.g. by feature/responsibility), the new file names, and how imports will be updated across the codebase. List "out of scope" so you don't rewrite logic. Wait for my approval before editing. After I approve, make the change, update all imports, run the app to confirm nothing broke, and create a checkpoint.

Run this in Plan Mode. Refactor the [ComponentName] component: it's too big and hard to follow. Break it into smaller components and/or hooks, lift shared logic out, and clean up state — without changing what the user sees or how it behaves.

Propose the new component/hook breakdown and the prop interfaces before editing, and list what's out of scope. Keep the rendered output and interactions identical. After I approve, implement it, test the component's interactions in the browser, and create a checkpoint. Don't touch unrelated components.

There's duplicated logic across [describe, e.g. "the create and edit forms" or "several API handlers"]. Consolidate it into one shared, well-named function/module without changing behavior.

First, show me the duplicated blocks you found and the single abstraction you propose — I want to make sure the cases are actually the same before you merge them. Only unify code that's genuinely identical in intent; don't force-fit different cases into one function. After refactoring, run the affected features and confirm each still behaves the same. Create a checkpoint.

Add tests for [file/module/feature]. Focus on the important behavior and edge cases, not trivial getters.

Cover: the happy path, the main error cases, and boundary conditions [list any you care about, e.g. empty input, max length, invalid values]. Use the project's existing test setup if there is one, otherwise set up a lightweight, standard test runner. Don't change the code under test — if you find a bug while writing tests, tell me instead of silently fixing it. Run the tests, make sure they pass, and create a checkpoint.

We just fixed this bug: [describe the bug and the fix]. Add a focused regression test that fails on the old buggy behavior and passes with the fix, so it can't come back.

Write the test to assert the correct expected behavior for the exact condition that used to break: [describe the trigger/input]. Keep it small and clearly named after the bug. Run it to confirm it passes now. Don't add unrelated tests or change other code. Create a checkpoint.

Improve error handling across [the app / a specific feature]. Right now failures [crash the page / show a blank screen / expose a raw error].

For each place that can fail (API calls, form submits, data loading), catch errors gracefully, show the user a clear, friendly message, and keep the rest of the app usable. Add loading and empty states where they're missing. Log the technical detail for me but never show stack traces or secrets to the user. Tell me the list of places you're changing first. Test a few failure cases in the browser and create a checkpoint.

I have a bug I can't pin down: [describe the symptom]. Before trying to fix it, add targeted logging so we can see what's actually happening.

Add clear, labeled log statements at the key points in the suspect flow [name the flow/files]: inputs, branch decisions, external call results, and the final output — enough to trace the path. Don't log secrets or full personal data. Tell me exactly what to do to trigger the flow, then read the logs and tell me what they reveal about the root cause. Once we understand it, we'll fix it. Create a checkpoint after adding the logging.

Run this in Plan Mode. I have a database problem: [describe, e.g. "a migration failed" / "a column is missing" / "queries error after a schema change" / "I need to add a field to an existing table"].

Error (if any): [paste it]. Current behavior: [X]. Expected: [Y].

Because this touches data, propose a plan before making changes: what schema change or migration you'll run, whether existing data is affected, and how to avoid data loss. Wait for my approval. Prefer a safe, reversible migration. After I approve, apply it, verify the schema and a sample query, and create a checkpoint. Never drop or overwrite data without explicitly confirming with me.

Do a security review of the app before I share it more widely. Report findings first; don't make sweeping changes without my say-so.

Check for the common issues: secrets or API keys hardcoded in the code, missing authentication/authorization on routes that need it, unvalidated user input (injection, XSS), sensitive data exposed in responses or logs, and insecure direct object references (users accessing others' data). Give me a prioritized list — High/Medium/Low — with the file/line and a one-line fix each. Then fix the High items with my approval, keeping each change scoped, and create a checkpoint after each fix.

We've gone in circles on this bug and things are worse than when we started. Let's reset.

Stop trying new fixes. First, do NOT edit any code yet. Look at the History and tell me which recent checkpoint was the last known-good state for [feature]. I'll roll back to it. Then, in Plan Mode, focus on ONLY this single symptom: [one precise symptom + exact error]. Investigate and explain the root cause before proposing anything. Propose the smallest possible fix and wait for my approval. Nothing else is in scope. After the fix, add a test for it so it can't regress.