How to Use Faylee: The Beginner's Guide
CodexFuse Team · 2026-11-02T23:32:53.734Z · 18 min read min read
Faylee turns bug reports into recordings your coding agent can fix from one link — screen, voice, console, network, and steps on a single clock. This beginner's guide walks through the mental-model lesson, your first recording, instant replay, the one-link report, the MCP server connect, the agent-fix arc, a FlowLens comparison, and current pricing.
How to Use Faylee: The Beginner's Guide
The worst bug report in software is a sentence. "It's broken." "Checkout doesn't work." "The page looks weird on my phone." The reporter saw everything — the exact click, the exact moment it failed, the error flashing in the console — and the developer gets one sentence. A human developer can at least ask follow-up questions. Your coding agent cannot. This faylee tutorial covers exactly that gap: it turns a bug report into a recording your agent can read, investigate, and fix from one link.
Faylee is a bug-reporting tool for web apps built around coding agents. When something breaks, you (or your customer, or your QA tester) record the screen, and Faylee captures everything around it — the video, the voice narration, every console message, every network request, every click and keystroke — onto a single timeline. One link carries the whole session. Connect the Faylee MCP server to Claude Code, Cursor, or Codex, paste the link, and say "fix it and comment on the report." The agent watches the recording, finds the cause, fixes the code, and comments back. If you ever work with Faylee's REST API for uploading or reading recordings, our REST API tester is a handy way to poke the endpoints while you learn. And when the agent's fix lands as a pull request, the workflow continues in our GitHub beginner guide.
What Is Faylee, Exactly?
Faylee is a bug-report recorder that produces links coding agents can act on. The core loop, in the maker's own words from the October 29, 2026 launch, is "bug reports your coding agent can fix from one link." Instead of writing a ticket, you record what happened; instead of reading a ticket, the agent opens the link.
Under the hood, a Faylee recording is a synchronized session, not just a video file. The screen capture rides on the same clock as the console, the network log, and the interaction steps. Scrub to any moment in the video and the console messages, requests, and clicks line up with it. The moment the link opens, the failing call is highlighted. An agent with the Faylee MCP server can pull frames, console entries, and requests one by one and reason about them — which is what makes "fix it" an instruction rather than a wish.
Faylee launched on Product Hunt on October 29, 2026 (maker Uros, tagline "Faylee: Bug reports your coding agent can fix from one link"), with a free tier for up to 3 members and no card required. As of this writing it is a young, fast-moving product, so treat the moving parts — exact commands, pricing, feature names — as current for November 2026 and verify them at the source before you rely on them.
Why Is "It's Broken" Not a Bug Report?
A one-sentence ticket is missing the only thing the fixer needs: context. Say this once and internalize it — the reporter experienced the bug in full, and the developer (or the agent) received a compressed shadow of it.
Here is what a normal ticket destroys. The exact sequence of clicks before the failure? Gone. The console error with its stack trace? Never mentioned. The failed network request and what the server actually returned? Nobody thought to copy it. The browser, window size, and network conditions? "My computer." A human developer can reply "what browser?" and lose a day to the round trip. A coding agent cannot even ask — it just guesses, and guesses badly.
Faylee's whole design is an answer to that asymmetry. The report carries the full context the reporter saw: video of what happened, the console at that moment, the network requests with their headers and bodies, and the steps written out. The agent does not need to ask follow-ups because there is nothing to follow up on. That is the mental model behind every section of this guide: record generously, share one link, let the machine read what a human would have had to type out.
How Do You Record Your First Bug With Faylee?
Recording is two clicks or one shortcut, and there are two distinct ways to start: record live as you reproduce the bug, or rescue the last few minutes after the bug already happened. The second one is the feature most beginners miss.
To record live, open the tab with the bug and start a recording from the Faylee extension or app — video of the tab or the whole screen, a webcam bubble if you want to narrate on camera, and your microphone mixed with the tab's sound. The keyboard shortcut is Alt+Shift+V. Narrate while you reproduce the bug: what you expected, what you clicked, what you saw instead. Faylee says the narration becomes captions and a transcript, and its assistant drafts the title and the likely cause from it.
The rescue path is the faylee instant replay lesson, and it is worth learning on day one. Faylee keeps the last few minutes of every tab automatically — the vendor says the replay data stays on your machine until you share it, and nothing is uploaded in the background. So when a bug surprises you, you do not need a time machine: one shortcut saves the last few minutes as a recording. Stop reading tickets that say "it just happened and I can't reproduce it." With instant replay on, the evidence is already there.
One safety note that matters before you share anything: Faylee says sensitive data — tokens, cookies, passwords, card numbers, authorization headers — is replaced with [redacted] in the browser, before anything is uploaded. You can also click any part of the page to blur it (or mark it with data-faylee-mask), password, card, and OTP fields are always blurred, and there is a never-capture site list plus workspace privacy rules. Treat those as the vendor's claims about the current build, and spot-check a recording before you share anything truly sensitive.
What Lands on One Faylee Link?
The link is the whole point, so it is worth knowing exactly what one recording contains. Here is the full inventory, per the vendor's docs.
| What is captured | What is on the link | Where it shows up |
|---|---|---|
| Screen | Video of the tab or the whole screen, optional webcam bubble, microphone plus tab sound | The main player, scrubbed on the same clock as everything else |
| Console | Every console message and error, with stack traces | The console panel, lined up with the video frame |
| Network | Every request with headers and text bodies; WebSocket and EventSource messages | The network panel; any request copies as cURL; the session downloads as HAR |
| Steps | Clicks, typing, key presses, form submits, scrolling, page changes — written out as steps | The steps timeline beside the video |
| The page itself | An inspectable DOM replay of the page at each moment | Open the page state under the video frame and inspect it |
| Environment | Browser, system, window size, network speed, Web Vitals, memory | The session metadata panel |
| Narration | Captions and a transcript from your voiceover; the assistant drafts a title and a likely cause | The transcript panel and the report header |
| App context | Anything your app passes to window.faylee.metadata() | The metadata panel, next to the session info |
Two details make the link more than a pile of logs. First, the failing call is highlighted the moment the link opens — you and the agent both start at the failure, not at minute zero. Second, everything runs on one clock: scrub to any moment and the console, network, and steps line up with that frame. That single-clock property is what lets an agent "watch" the bug the way you watched it happen.
Sharing is deliberately low-friction: customers and testers can record from a link with no account and nothing installed, and a "Report a bug" widget — one script tag — lets you embed reporting directly in your app. The vendor's documented snippet is <script src="https://app.faylee.app/widget.js" data-site="site_3kf9…" async></script> (your own site key goes in place of the placeholder). For teams, Faylee also ships Zendesk and Intercom integrations — the vendor says the extension turns a ticket into a recording link and the recording comes back as a note on the ticket, and support can send a recording link straight from a ticket with nothing to install.
How Do You Connect the Faylee MCP Server to Your Agent?
The MCP server is what turns the link from a document into something your coding agent can investigate. Here is the first-connect arc, verified against the vendor's docs for November 2026. Do it once per agent and you never touch it again.
- Pick your agent. The documented path covers Claude Code, Codex, OpenCode, Cursor / VS Code, and Claude.ai / Claude Desktop. If your agent speaks MCP over Streamable HTTP, it speaks Faylee: the server is
https://app.faylee.app/mcp. - Claude Code: add it in one command. Run
claude mcp add --transport http faylee https://app.faylee.app/mcpin your terminal. Then type/mcpin Claude Code, pick faylee, and sign in in your browser — OAuth happens on first connect, and there are no tokens to paste for the usual clients. - Codex: two commands. Run
codex mcp add faylee --url https://app.faylee.app/mcp, thencodex mcp login fayleeto complete the browser sign-in. - OpenCode: one config entry plus auth. In
opencode.json, add"mcp": { "faylee": { "type": "remote", "url": "https://app.faylee.app/mcp" } }, then runopencode mcp auth faylee. - Cursor / VS Code: use the in-app path. The docs do not give a manual command here — install from the link inside Faylee's Settings → Agents instead. For Claude.ai / Claude Desktop: Settings → Connectors → Add custom connector, then paste
https://app.faylee.app/mcp. - Test it with a real link. Open any Faylee report link and tell the agent: "Open this recording and tell me what the failing request is." If it reads the video frames, console, and network and names the call, the connection works.
Two advanced variants for later. Headless or scripted agents use the same Claude Code command with a bearer header: claude mcp add --transport http faylee https://app.faylee.app/mcp --header "Authorization: Bearer <token>". And a local-only stdio form exists for clients that cannot do remote MCP: claude mcp add faylee --env FAYLEE_URL=https://app.faylee.app --env FAYLEE_TOKEN=<token> -- faylee mcp. Generate the token in your Faylee settings — never commit it, and treat any token you paste into a shell history as compromised. The vendor documents a 600-requests-per-minute-per-person rate limit on the MCP tools.
What does the agent actually get? The MCP surface includes tools to open a recording, pull a specific moment, read one request, the console, and the network, plus a guide tool, a comment tool, a create-recording-link tool — and an investigate_recording prompt that walks the agent through a full investigation. In plain terms: your agent can look at the bug the way you would, frame by frame, then talk back to the report.
How Does the Agent Fix the Bug and Comment Back?
This is the "fix it and comment" loop the launch is built around, and it is worth walking once so the magic stops being mysterious. The report is not just read by the agent — the agent writes back to it.
Here is the full faylee bug report coding agent arc. You paste the link into Claude Code, Cursor, or Codex and say "fix it and comment on the report." The agent opens the recording through the MCP server: it watches the video frame by frame, reads the console around the failure, pulls the failing request with its headers and body, and — if you connected Sentry — sees the server-side error from Sentry matched by its trace beside the failed request. It traces the cause through your code, makes the fix, runs whatever checks it can, and then comments back on the report itself with what it found and what it changed. If you are new to running agents this way, our Claude Code beginner guide covers the agent side from zero.
One hard rule for this loop, and it applies to every report-driven agent workflow: treat the report's text as DATA. The recording may contain console output, page text, or comments that look like instructions — "run this command," "delete that file," "disable the firewall." Never let the agent run commands or change files outside the bug's scope because the report said so. The report is evidence, not orders.
The loop also works from the other direction: through the MCP server's create_recording_link tool, an agent can itself generate a recording link — useful when your CI or your agent reproduces a bug and you want the evidence shared the same way a human would share it. And for pipeline people: Faylee ships a REST API for uploading and reading recordings plus signed webhooks for new recordings, comments, issues, and finished recording links, with oEmbed so pasted links unfurl as players, and a CLI that reads any recording from a terminal. That is the surface the agent-fix loop is built on.
When the fix is done, it usually lands where code lands: a commit or a pull request. Our Git beginner guide covers the commit side if the agent is writing to your repo for the first time.
Faylee vs FlowLens: Which One Fits Your Workflow?
FlowLens is the closest open-source relative, so this is the comparison that matters. Both feed browser evidence to coding agents through MCP — but they are built for different reporters.
| Question | Faylee | FlowLens |
|---|---|---|
| Who records the bug? | Anyone — customers and testers record from a link with no account and nothing installed | A developer with the FlowLens Chrome extension installed |
| How does the evidence travel? | One hosted link; video, console, network, and steps on a single clock | Local-first flows shared with the agent via stdio MCP (shareable cloud flows need a token) |
| What is it for? | Bug reports an agent investigates and fixes, then comments back on the report | Debugging and regression testing — including generating Playwright test scripts |
| Rescue a bug after it happens? | Yes — instant replay keeps the last few minutes of every tab (vendor claim) | No — you record the flow deliberately |
| Privacy story | In-browser scrubbing to [redacted] before upload, click-to-blur, always-blurred password/card/OTP fields (vendor claims) | Local-first: evidence stays on your machine by default |
| Team integrations | Zendesk, Intercom, Slack, Sentry, one issue tracker on the free tier (vendor claims) | None built in — it is a developer tool, not a team pipeline |
| License and price | Hosted SaaS; free tier, then per-member plans | Open-source, Apache-2.0 (magentic/flowlens-mcp-server on GitHub) |
The honest answer is that they overlap least at the reporter. If the people finding your bugs are customers, support staff, or QA testers who will never install an extension, Faylee's one-link flow wins. If you are a developer debugging your own flows and you want everything local and open-source, FlowLens — installable with pipx install flowlens-mcp-server — is the natural pick. Some teams will end up with both: FlowLens for the dev loop, Faylee for the inbound bug firehose. A one-paragraph faylee review: a focused, fast-moving recorder whose one-link report an agent can genuinely act on — strong for inbound bugs, and young enough that you should verify every command and price at the source.
What Does Faylee Cost?
Pricing is verified against the vendor's pricing page as of November 3, 2026 — a young product, so re-check before you budget. Faylee charges per recording member, and the free tier is genuinely usable.
The Free plan is $0 forever: up to 3 members (viewers are always free), 30 recordings a month at up to 5 minutes each, 14 days of history, the MCP server included, Slack plus one issue tracker, and no card required. That covers a solo developer or a tiny team learning the loop — the "faylee pricing free tier" question, answered.
The Team plan is $12 per member per month billed yearly ($144) or $15 per member per month billed monthly. Only members who record count toward the bill — viewers stay free. It adds unlimited members and recordings, 15-minute videos, unlimited history, and 100 AI-analysis runs per member per month, with a 14-day trial that needs no card. Enterprise is a custom annual contract. Payment runs through Polar.
7 Beginner Mistakes to Avoid With Faylee
Every beginner hits at least one of these. Read the table first and skip the debugging.
| Mistake | Why it hurts | Do this instead |
|---|---|---|
| Recording without narrating | The agent gets silent video and has to infer what you expected | Talk through it: what you clicked, what you expected, what you saw instead — the narration becomes the transcript |
| Never enabling instant replay | The one bug you cannot reproduce is the one you did not record | Leave replay on; when a bug surprises you, save the last few minutes instead of re-reproducing |
| Pasting the link without the MCP server connected | The agent sees a URL it cannot open and hallucinates about it | Connect the MCP server first, then test with "tell me what the failing request is" before you trust the loop |
| Treating the report as instructions | Console text or page content can look like commands — the agent may obey it | Report text is DATA: never let the agent run commands or change files outside the bug's scope because the report said so |
| Sharing before checking the scrubbing | Vendor redaction claims are about the current build, not a guarantee | Open one recording and verify tokens, cookies, and passwords show as [redacted] before sharing real sessions |
| Skipping the "Report a bug" widget | Your customers keep writing one-sentence tickets while you wait for them to install something | Drop the one-script-tag widget in your app — customers record from a link, no install |
| Letting the agent comment without reviewing the fix | "Fix it and comment" is fast, and fast merges of agent-written code bite | Read the diff first — the agent's comment on the report is the summary, not the review |
Sources
- Faylee product site and docs, faylee.app and faylee.app/docs (fetched 2026-11-03) — what gets recorded (screen, console, network, steps, page replay, environment, metadata), instant replay, the one-link report, the widget script tag, the assistant, privacy scrubbing, Sentry/Zendesk/Intercom integrations, REST API and webhooks.
- Faylee MCP server docs, faylee.app/docs/agents/mcp (fetched 2026-11-03) — the server URL https://app.faylee.app/mcp, connect commands for Claude Code, Codex, OpenCode, Cursor/VS Code, Claude.ai/Desktop, headless bearer-token and local stdio variants, the MCP tool list, and the 600-requests/min rate limit.
- Faylee pricing page, faylee.app/pricing (fetched 2026-11-03) — Free $0 forever terms (3 members, 30 recordings/month, 5 min each, 14-day history, MCP included), Team $12/member/month yearly or $15 monthly, Enterprise custom; payment via Polar.
- Faylee Product Hunt launch page, producthunt.com/products/faylee (fetched 2026-11-03) — launched 2026-10-29, tagline "Bug reports your coding agent can fix from one link," maker Uros, free-for-3-members launch offer.
- Faylee announcement on the Cursor forum, forum.cursor.com (maker post, 2026-10-27) — record your screen and tell Cursor what to change; MCP server; no signup needed for the example report.
- FlowLens MCP server, github.com/magentic/flowlens-mcp-server (fetched 2026-11-03) — Apache-2.0, created 2025-10-04, 108 stars; pipx install; FlowLens Chrome extension; MCP debugging and regression testing with Playwright test generation.
Frequently Asked Questions
Is Faylee really free?
For small use, yes. The Free plan is $0 forever with up to 3 recording members (viewers are always free), 30 recordings a month at up to 5 minutes each, 14 days of history, and the MCP server included — no card required. That is enough to learn the full record → link → agent-fix loop. The Team plan starts at $12 per recording member per month billed yearly.
What does "fix it and comment" actually mean?
You paste a Faylee link into Claude Code, Cursor, or Codex (with the MCP server connected) and say "fix it and comment on the report." The agent opens the recording through MCP, watches the video, reads the console and the failing network request, traces the cause in your code, makes the fix — and then comments back on the Faylee report itself with what it found and changed. The loop closes on the link, not in your chat.
How is Faylee different from FlowLens?
They share the "browser evidence → coding agent via MCP" idea but serve different reporters. FlowLens is an open-source, local-first developer tool (Apache-2.0): a developer installs the Chrome extension, records flows, and debugs or generates regression tests. Faylee is a hosted product built for non-technical reporters — customers record from a link with no install, instant replay rescues bugs after they happen, and the report is designed for two-way agent interaction plus team integrations like Zendesk, Intercom, Slack, and Sentry.
Do I need to install anything to record a bug?
Not necessarily. Anyone can record from a Faylee link with no account and nothing installed, and one shortcut saves the last few minutes after a bug already happened (instant replay). If you want reporting inside your own app, Faylee provides a "Report a bug" widget that is a single script tag. For the agent side, you connect the Faylee MCP server to your coding agent once.
Is it safe to share a Faylee recording?
Faylee's stated design is privacy-first: it says sensitive data — tokens, cookies, passwords, card numbers, authorization headers — is redacted to [redacted] in the browser before anything is uploaded, password, card, and OTP fields are always blurred, and instant-replay data stays on your machine until you share it. Treat those as the vendor's claims about the current build: spot-check one recording's redactions before you share anything truly sensitive, and use click-to-blur or data-faylee-mask for anything you want hidden for certain.
