Tabnine vs Replit AI: Which AI Coding Tool Should You Choose?

QA v1.0 — 2026-05-26 KST. content_status = qa_passed. Generated from templates/comparison-page-template.md and promoted after an independent Section B walk-through of qa/adsense-seo-quality-gate.md. Meta description (≤ 155 chars): Tabnine is a governed AI coding assistant you run inside your own editors and boundary; Replit AI builds and publishes apps in a browser tab — here is the choice.

Quick recommendation

• Choose Tabnine if: your organization needs an AI coding assistant that runs inside the editors your developers already use (VS Code, JetBrains, a CLI named on the homepage) and, more importantly, inside your own deployment boundary — SaaS, a private cloud (VPC), on-premises, or fully air-gapped — with code privacy, governance, and license-risk controls treated as first-order procurement requirements. Tabnine's positioning on 2026-05-26 ("The Missing Layer in Enterprise AI: Context" / "Smarter AI Coding Agents. Total Enterprise Control.") and its priced annual per-seat platform tiers (Code Assistant at $39/user/month annual, Agentic Platform at $59/user/month annual) are built around that enterprise-control buyer.
• Choose Replit AI if: you want a single browser tab that holds the editor, the runtime, the AI agent, and the hosting all at once — describe an app in natural language and have something runnable and publishable a few minutes later, on whatever machine you happen to be on. The canonical fit is education, hobby projects, prototyping, classroom and bootcamp work, internal demos, and "ship a quick thing" loops where a local toolchain is inconvenient or impossible. Replit's plan ladder (Starter Free, Core at $20/month billed annually, Pro at $95/month billed annually, Enterprise custom) escalates by Agent credits, parallel agents, and model access rather than by editor seats.
• Consider another option if: you want an AI-first dedicated editor where agentic multi-file edits are the default and you are willing to switch editors (look at Cursor), you want AI inside the editor you already use plus the GitHub repo/PR/review workflow (look at GitHub Copilot), or your top need is a general-purpose chat assistant where code is one of many tasks rather than the whole job (look at Claude).
• Last verified: 2026-05-26 KST. Underlying source reads: tabnine.com/ and tabnine.com/pricing/ on 2026-05-26 KST; replit.com/ai and replit.com/pricing on 2026-05-23 KST.

Short answer

Tabnine and Replit AI are both routinely described as "AI tools developers use," and a fair amount of search traffic lines them up as direct competitors. They compete only loosely. Both have an AI coding-agent surface, and both can generate, edit, and reason about code. But the two products live in very different environments and answer two very different questions: where do your code, your runtime, and your deploy target run, and is AI a controlled layer inside the editor and boundary you already have, or the whole build-and-publish environment itself.

Tabnine is an AI coding platform from Tabnine Ltd. Its homepage on 2026-05-26 frames the product around enterprise control and organizational context rather than around being the flashiest autocomplete: the headline reads "The Missing Layer in Enterprise AI: Context," supported by "Smarter AI Coding Agents. Total Enterprise Control." The product describes AI code completion, AI chat positioned across the software development lifecycle, agentic workflows for multi-step work, and an "Enterprise Context Engine" meant to give agents organizational intelligence about a specific codebase. The two themes Tabnine emphasizes more than most competitors are deployment flexibility ("Deploy anywhere — SaaS, on-prem, or fully air-gapped") and data handling ("Total code privacy & zero data retention"), plus a selectable underlying LLM, all delivered inside editors a team already uses (VS Code, JetBrains, and a CLI named on the homepage). The pricing axis is per-seat and paid: the pricing page on 2026-05-26 listed Tabnine Code Assistant at $39/user/month and the Tabnine Agentic Platform at $59/user/month, both on an annual subscription, with no free plan, free tier, or free trial visible on that date, and enterprise/self-hosted deployments handled by custom quote.

Replit AI is the AI feature layer inside Replit, a browser-based development platform. The product surface on 2026-05-23 frames Replit around the "Agent" — you describe an outcome in natural language ("a small CRUD tool for tracking bookings," "a Discord bot that does X"), and Replit's agent builds, edits, runs, and deploys the app without leaving the browser tab. Where Tabnine assumes you already have editors, a toolchain, a runtime, a deploy target, and — crucially — a deployment boundary you control, Replit puts the editor, the runtime, the AI agent, and the hosting in one browser tab. The plan structure on the pricing page escalates by Agent usage rather than by editor seat: Starter (Free) with free daily Agent credits and the ability to publish up to 1 project; Replit Core at $20/month billed annually with $25 of monthly Agent credits and up to 2 parallel agents; Replit Pro at $95/month billed annually with $100 of monthly Agent credits, up to 10 parallel agents, and access to the most powerful models; and Enterprise at custom pricing.

That environmental difference is most of the decision. If your binding constraint is "the AI assistant and the code it sees must run inside our own boundary — under governance, code-privacy, and license-risk controls, possibly air-gapped — and developers must keep working inside the editors they already use," Tabnine is built around that requirement, and its $39/$59 annual per-seat tiers are priced for that enterprise-control buyer. If your binding constraint is "describe a small app and get something runnable and publishable in minutes, from a browser, with no local setup," Replit AI is the right shape of product. They are not universal substitutes: Tabnine is for governed in-editor and internal-code workflows; Replit AI is for hosted, browser-based app building, prototyping, and education. They can even be complements — Replit AI for the classroom, the demo, and the throwaway prototype; Tabnine for the production code that must stay inside a controlled or air-gapped environment. This page makes no claim that either tool produces better code — quality varies across languages, tasks, model versions, and prompt shapes, and both products' model lineups change frequently. Where a price, quota, credit definition, or region-specific figure was not visible on the official page on the date read, this page routes you to verify on the official site rather than asserting a number.

Comparison table

Use-case based choice

For writing and editing

Neither product is built for general writing. Both are coding tools whose chat or agent surfaces happen to render natural language. If your real job is documents, memos, contracts, or marketing copy with code as a side task, neither Tabnine nor Replit AI is the right primary purchase — you want a general-purpose chat assistant like Claude or a writing-specific product, and you can layer one of these two on top later if you also build software.

Within the narrow space of "writing as part of a build workflow" — design notes, README files, project descriptions, commit messages, code comments — both tools can produce these artifacts from the code they see. Tabnine's in-IDE chat can draft them inside the editor where the code lives, under the deployment and data-handling controls Tabnine leads with; Replit AI can generate a README, a project description, or inline comments as a side effect of building the app in the browser. Neither is distinctive at developer-adjacent writing, and neither is a substitute for a real writing tool.

The practical takeaway: do not pick between these two on writing grounds. Pick on the environment-and-control dimension below.

For coding and technical work

This is where the comparison matters, and the right answer depends much less on "which one writes better code" than on where the code, the runtime, and the AI are allowed to run — and on whether you need to keep working in your existing editors and boundary or want the whole environment handed to you in a browser tab.

Tabnine's strongest surface is a governed AI coding assistant you can deploy on your own terms, with organizational context, inside the editor you already use. The homepage on 2026-05-26 describes AI code completion (single-token and multi-line, drawn from project context), AI chat positioned across the SDLC, and agentic workflows for multi-step work, all wrapped in an "Enterprise Context Engine" intended to map a specific organization's dependencies, architecture, and workflows. The pricing page describes the entry tier (Code Assistant, $39/user/month annual) as covering line and multi-line full-function completion, in-IDE SDLC chat, operation across major IDEs, Jira integration, a "Zero code retention policy with end-to-end encryption," "License-safe AI usage," and flexible deployment (SaaS, VPC, on-premises, air-gapped). The Agentic Platform tier ($59/user/month annual) adds autonomous agents with optional user-in-the-loop oversight, the Tabnine CLI, codebase connections across Bitbucket, GitHub, GitLab, and Perforce, MCP tool integration, and advanced governance and analytics. Treat the "zero data retention" and "License-safe AI usage" lines as vendor claims — confirm the exact terms for your deployment mode against Tabnine's official documentation, and do not treat the license language as legal advice. The defining trait: Tabnine works against the production codebase that already lives in your repositories, inside the boundary you control.

Replit AI's strongest surface is going from an idea to a running, published app without leaving the browser. You describe an outcome, and the Agent scaffolds a project, writes the files, installs dependencies, runs the app, and can publish it to a live URL — all in one tab, with no local toolchain to set up. That is a genuinely different job from "assist me inside my existing editor": Replit supplies the editor, the runtime, and the hosting as part of the product. For a student on a Chromebook, an educator running a class of thirty, a founder validating an idea over a weekend, or an engineer throwing together an internal demo, that zero-setup loop is the whole value. The trade-off is the mirror image of Tabnine's strength: Replit is a hosted platform, so the code, runtime, and deploy target live on Replit's infrastructure — exactly what you do not want for proprietary or compliance-sensitive code that must stay inside your own boundary.

The honest split:

• If your binding constraint is "the AI and the code it sees must run inside our boundary" — private cloud, on-premises, or fully air-gapped — Tabnine is built around that requirement, and Replit's hosted browser platform is not the fit. This is Tabnine's most distinctive reason to exist.
• If your binding constraint is "get from idea to a running, publishable app in minutes with no local setup," Replit AI's whole environment is built around that, and Tabnine — an assistant inside editors you already run against repositories you already have — does not supply the runtime and hosting.
• If your primary constraint is "the lowest-friction free start today," Replit has the easier on-ramp: a published Starter Free tier with daily Agent credits and one project publish, usable from a browser with no install. Tabnine listed no free plan or trial on 2026-05-26, so evaluating it means engaging with sales (verify on the official site if a free path has since returned).
• If you need AI inside the editors your developers already use (VS Code, JetBrains, CLI) with no requirement to move work into a browser environment, Tabnine is the natural fit; Replit asks you to build inside its hosted tab. And if your work spans the production codebase across multiple source hosts (Bitbucket, GitHub, GitLab, Perforce) under centralized governance, Tabnine's Agentic Platform tier is built around that; Replit's strength is greenfield apps started inside the platform, not governed access to large existing repositories.

None of this is a benchmark claim. Treat any "X writes better code than Y" headline as out-of-date by the time you read it; evaluate on the work you actually ship, inside the deployment mode (Tabnine) or project type (Replit) you would actually use.

For research and fact-checking

Neither tool is a citation-first research engine. Both are coding tools whose surfaces will generate fluent text about the world; both will hallucinate when the input is sparse, dated, or contradictory; and neither presents inline citations the way a dedicated answer engine does.

For code-specific "research" — understanding a function, recovering the intent of an unfamiliar codebase, scaffolding a test, exploring an API — both are reasonable in their own contexts. Tabnine's Enterprise Context Engine is positioned to answer such questions against an organization's own mapped codebase, dependencies, and architecture, which is the more relevant shape when the codebase is large, private, and must stay inside the organization's boundary. Replit AI is the more direct surface for "spin up a small working example so I can see how this library behaves," because it runs the example for you in the same tab. Either tool's answer should be cross-checked against the actual code or the official documentation before it ships. For general fact-finding about the world (recent events, market data, scholarly references, regulatory text), neither is the right tool — use a dedicated answer engine or a real search engine, then verify against primary sources.

For teams or businesses

The team buying decision tracks the deployment-control difference, the environment difference, and the pricing axis — and it is best treated as two separate yes/no decisions, sized independently, rather than a single head-to-head.

• Tabnine for teams and enterprises is sold through the per-seat platform tiers (Code Assistant at $39/user/month annual; Agentic Platform at $59/user/month annual) plus enterprise/self-hosted deployments via custom quote, with an optional Headless Agents CI/CD add-on priced separately (the add-on amount and the enterprise/self-hosted figures were not stated on the 2026-05-26 page — verify on the official site). The distinctive procurement tell is deployment isolation: Tabnine names SaaS, VPC, on-premises, and fully air-gapped as deployment options, paired with a stated "zero code retention" posture and "License-safe AI usage" claim. For organizations with strict data-residency, regulatory, or zero-trust requirements, that isolation story is the central reason to evaluate Tabnine — but confirm the exact data-handling terms for your deployment mode against Tabnine's official documentation, and treat the license-safety language as a vendor claim rather than legal advice. The buyer is your developer headcount working in existing editors against existing repositories.
• Replit AI for teams is sold through usage-priced seats (Core at $20/month annual; Pro at $95/month annual) and Enterprise at custom pricing. The differentiator is Agent budget and parallelism (monthly Agent credits, up to 2 parallel agents on Core, up to 10 on Pro) rather than per-seat editor licensing. The natural team buyers are education programs, bootcamps, hackathons, internal tooling and prototyping groups, and product teams that want a fast shared place to build and publish demos. Because Replit hosts the code and runtime, the buying question must include whether a hosted browser platform is acceptable for that team's work — for proprietary or compliance-sensitive production code it usually is not, and that is where Tabnine (or another assistant that runs inside your own boundary) comes in.

For an organization whose binding requirement is on-prem or air-gapped deployment with governance and license-risk controls, Tabnine is the more direct purchase. For a team whose job is teaching, prototyping, demos, or fast browser-based app building, Replit AI's usage-priced plans are the more direct purchase, with a Starter Free tier to evaluate first. Some organizations will run both — Replit AI for the classroom, the demo, and the throwaway prototype; Tabnine for the production code that must stay inside a controlled or air-gapped environment. That combined bill is sized on different axes (per-seat for Tabnine, per Agent-usage for Replit); decide whether each tool earns its line item against the population that actually uses it.

Admin/SSO availability, data-handling for AI inputs and outputs, code and conversation retention policy per tier and per deployment mode, the selectable-LLM or model-access list, IDE feature parity, the exact Agent-credit definitions and parallel-agent caps, regional plan availability, and the precise scope of the "License-safe AI usage" and "zero data retention" claims should all be confirmed on each vendor's official docs before procurement. Treat each vendor's published policy as the only authoritative source on what is and is not used for model training or improvement.

Pricing and plan caveats

• Tabnine: the page-body read of tabnine.com/pricing/ on 2026-05-26 KST showed Tabnine Code Assistant at $39/user/month and the Tabnine Agentic Platform at $59/user/month, both annual subscription; an optional Headless Agents add-on for CI/CD priced separately; and enterprise/self-hosted deployments via custom quote. No free plan, free tier, or free trial was listed on that date, and only an annual cadence was shown. A monthly-billing option, the Headless Agents add-on price, exact enterprise/self-hosted pricing, the complete supported-IDE list, region-specific pricing, and any historical free tier were not asserted from this fetch and should be verified on the official site.
• Replit AI: the page-body read of replit.com/pricing on 2026-05-23 KST showed Starter at Free with free daily Agent credits and the ability to publish up to 1 project; Replit Core at $20/month billed annually with $25 of monthly Agent credits and up to 2 parallel agents; Replit Pro at $95/month billed annually with $100 of monthly Agent credits, up to 10 parallel agents, and "access to the most powerful models"; and Enterprise at custom pricing inheriting Replit Pro capabilities. The annual prices were framed as discounts versus unstated standard monthly rates. The exact daily Starter Agent-credit allowance, what each Agent credit buys and how usage is counted, the precise definition and limits of "parallel agents," the exact frontier-model list on Pro, the month-to-month rates, any dedicated mid-team SKU, and region-specific pricing were not in scope and should be verified on the official site.

Both vendors have moved features, quotas, credit accounting, and model lineups between releases. Treat the numbers above as recent (May 2026) reference points, not long-term guarantees, and re-verify before quoting either page in a high-stakes decision.

Who should choose Tabnine

• Your organization cannot send source code to a hosted third-party service and needs on-premises or air-gapped deployment, or a private-cloud (VPC) boundary — a posture a hosted browser platform like Replit does not provide.
• Code privacy, deployment isolation, governance, and license-risk controls are hard procurement requirements, not nice-to-haves, and you want them as first-order product features.
• You want AI delivered inside the editors your developers already use (VS Code, JetBrains, CLI) and working against the production repositories you already have, rather than asking developers to build inside a hosted browser tab.
• You want an agentic coding platform that connects across multiple source hosts (Bitbucket, GitHub, GitLab, Perforce) under centralized governance and analytics, with an Enterprise Context Engine mapped to your own codebase.
• You can absorb annual per-seat pricing at $39 (Code Assistant) or $59 (Agentic Platform) per user, and the value case rests on deployment-control and governance features, not the lowest price or a free tier.

Who should choose Replit AI

• You want a single browser tab that holds the editor, runtime, AI agent, and hosting — and you value going from "describe an app" to "a live URL" in minutes with no local setup.
• Your context is education, hobby projects, prototyping, classroom or bootcamp work, hackathons, internal demos, or "ship a quick thing" loops — work where a hosted environment is an advantage, not a liability — and you want the lowest-friction free start: a Starter Free tier with daily Agent credits and one project publish, usable from any browser with no install.
• You prefer usage-based pricing that scales with how much you lean on the agent (monthly Agent credits, parallel-agent caps, model-access tiers) over per-seat editor licensing.
• A hosted browser platform whose code and runtime live on Replit's infrastructure is compatible with your data-handling needs — i.e., the code is not proprietary or compliance-sensitive in a way that requires it to stay inside your own boundary.

Bottom line

• Decide by where the code, runtime, and AI must run, and whether you need a controlled in-editor assistant or a hosted build-and-publish environment — not by which product sounds more capable in marketing copy. Tabnine is a governed AI coding assistant you run inside your existing editors and your own boundary (SaaS, VPC, on-prem, or air-gapped); Replit AI is a browser-based platform where the agent, editor, runtime, and hosting all live in one tab.
• If your binding requirement is on-prem or air-gapped deployment, code privacy, governance, and license-risk controls, default to Tabnine. Code Assistant at $39/user/month annual is the completion-and-chat tier; the Agentic Platform at $59/user/month annual adds autonomous agents, the Tabnine CLI, multi-host codebase connections, MCP, and governance/analytics; enterprise/self-hosted is a custom quote. There was no free tier on 2026-05-26, so plan to evaluate through sales.
• If your job is teaching, prototyping, demos, or fast browser-based app building, default to Replit AI. Starter Free is enough to evaluate the build-and-publish loop; Core at $20/month annual adds Agent credits and up to 2 parallel agents; Pro at $95/month annual adds more credits, up to 10 parallel agents, and the most powerful models; Enterprise is custom.
• These two are not universal substitutes, and for many organizations they are complements rather than rivals: Replit AI for the classroom, the demo, and the throwaway prototype; Tabnine for production code that must stay inside a controlled or air-gapped environment. If you run both, size each against the population that uses it and watch the combined bill.
• Re-verify both vendors' pricing pages directly before any commitment. Treat "License-safe AI usage" and "zero data retention" as vendor claims to confirm per deployment mode, not as legal advice, and treat all AI-generated code as proposals that require review and tests, not as finished work — a bar that is higher, not lower, when the AI also runs and deploys the result for you.

FAQ

Are Tabnine and Replit AI direct competitors? They overlap on the core job — AI that generates, edits, and reasons about code — but they are sold for different situations. Tabnine leads with enterprise control and deployment isolation (SaaS, VPC, on-prem, air-gapped), delivered inside the editors a team already uses, with priced per-seat platform tiers. Replit AI leads with a hosted, browser-based build-and-publish environment where the agent, editor, runtime, and hosting live in one tab, with a free starter tier and usage-based pricing. Many organizations will not choose one over the other so much as pick the one that fits the work in front of them — and some will run both for different jobs.

Which one is safer for proprietary or compliance-sensitive code? For code that must stay inside your own boundary, Tabnine is the closer fit on its face: it markets on-prem and air-gapped deployment plus "Total code privacy & zero data retention" and "License-safe AI usage." Replit is a hosted browser platform — the code and runtime live on Replit's infrastructure — which is generally not the posture you want for proprietary or regulated production code. That said, neither vendor's marketing is a substitute for reading the data-handling policy of the tier and deployment mode you intend to buy; confirm the exact terms against each vendor's official documentation, and treat license-safety language as a vendor claim, not legal advice.

Which one has the better free option? Replit has a published Starter Free tier with daily Agent credits and one project publish, usable from a browser with no install (the exact daily Agent-credit allowance — verify on the official site). Tabnine listed no free plan, free tier, or free trial on tabnine.com/pricing/ on 2026-05-26; Tabnine has offered a free tier historically, so reconfirm on the official site if free access matters to you. On these dates, Replit is the more legible free on-ramp.

Do I have to switch editors to use either one? Tabnine is delivered inside editors you already use — VS Code, JetBrains IDEs, and a CLI named on the homepage on 2026-05-26 (verify the full current list on the official site) — so there is no editor switch. Replit AI is not an extension for your existing editor at all; it is a hosted browser environment, so "using Replit AI" means building inside Replit's tab rather than your local IDE. If "do not move our work out of our existing editors and boundary" is a hard constraint, that points toward Tabnine; if "give me an environment with nothing to install" is the goal, that points toward Replit.

Which one is better for coding? Pick by environment and control, not by a quality headline. If the AI must run inside your boundary and your existing editors, Tabnine is the more direct answer; if you want a zero-setup browser environment that builds and publishes apps for you, Replit AI is. Both products' model lineups change frequently; do your own evaluation on the work you ship.

Are the prices on this page going to stay accurate? Treat them as recent (May 2026) reference points, not long-term guarantees. Both vendors have changed plans, quotas, credit accounting, and model lineups multiple times. Re-verify on tabnine.com/pricing/ and replit.com/pricing before any pricing-sensitive commitment.

Sources

• Tabnine official homepage: https://www.tabnine.com/ — recorded as src-tabnine-needs-verify in data/sources.json with access_status = ok after a 2026-05-26 page-body read. The id carries a legacy needs-verify semantic from the seed scan, but the current access status is ok. Cited here as the official product URL and for the homepage positioning ("The Missing Layer in Enterprise AI: Context", "Smarter AI Coding Agents. Total Enterprise Control."), the deployment options (SaaS, on-prem, air-gapped), the privacy posture ("Total code privacy & zero data retention"), the selectable LLM, and the surfaced editor/feature names (VS Code, JetBrains, CLI, Enterprise Context Engine).
• Tabnine official pricing page: https://www.tabnine.com/pricing/ — recorded as src-tabnine-pricing-2026-05-26 in data/sources.json with access_status = ok after a 2026-05-26 page-body read; this is the source of every Tabnine plan, price, plan-feature claim, and the absence of a free tier quoted on this page.
• Replit AI official product page: https://replit.com/ai — recorded as src-replit-ai-needs-verify in data/sources.json with access_status = ok after a 2026-05-23 page-body read. The id carries a legacy needs-verify semantic from an earlier fetch, but the current access status is ok. Cited here only as the official product/identity URL and for the browser-based Agent build-and-publish product surface; no pricing fact is drawn from it.
• Replit pricing page: https://replit.com/pricing — recorded as src-replit-pricing-2026-05-23 in data/sources.json with access_status = ok after a 2026-05-23 page-body read; this is the source of every Replit plan, price, Agent-credit, parallel-agent, and Starter free-tier claim quoted on this page.

All four entries above resolve to official first-party URLs. Re-verify the two pricing pages before any new pricing-sensitive quote. If a later refresh changes the access status of src-tabnine-needs-verify or src-replit-ai-needs-verify, this page does not need to be rewritten — it never asserts a fact from those identity/homepage sources beyond what is visible on them today.

Internal links

• /tools/tabnine/
• /tools/replit-ai/
• /tools/cursor/
• /tools/github-copilot/
• /tools/claude/
• /ai-coding/
• /compare/tabnine-vs-cursor/
• /compare/tabnine-vs-github-copilot/
• /compare/cursor-vs-replit-ai/
• /compare/github-copilot-vs-replit-ai/

Disclosure

• Affiliate links: none.
• Sponsored content: none. Neither Tabnine nor Replit has any relationship to this page.
• Generative AI assistance: this draft was assembled with the help of an AI assistant working from the HMP source records and the two qa_passed tool pages (tools/tabnine.md, tools/replit-ai.md).

Trademark notice

Tabnine is a trademark of Tabnine Ltd. Replit is a trademark of Replit, Inc. Cursor and Anysphere are trademarks of Anysphere. VS Code, Visual Studio, and Microsoft are trademarks of Microsoft. JetBrains is a trademark of JetBrains s.r.o. GitHub and Copilot are trademarks of GitHub / Microsoft. Bitbucket is a trademark of Atlassian. GitLab is a trademark of GitLab Inc. Perforce is a trademark of Perforce Software. Anthropic and Claude are trademarks of Anthropic. OpenAI is a trademark of OpenAI. Gemini is a trademark of Google. Jira is a trademark of Atlassian. Other vendor and product names mentioned on this page are the trademarks of their respective owners. Use here is referential only and does not imply endorsement, partnership, or affiliation with any vendor.

Update log

• 2026-05-26 (draft): first local draft created from templates/comparison-page-template.md. Both source tool pages (tabnine, replit-ai) are qa_passed per content/content-status.json.
• 2026-05-26 (QA): independent Section B walk-through completed. B1–B5 passed; content_status = qa_passed. Re-verify both vendors' pricing pages by 2026-08-21, which is 90 days from the older of the two source-read dates (2026-05-23 for Replit; Tabnine's 2026-05-26 reads remain valid through 2026-08-24).