[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill-launchdarkly-should-flag-change":3,"mdc--arcd8p-key":37,"related-repo-launchdarkly-should-flag-change":1814,"related-org-launchdarkly-should-flag-change":1900},{"slug":4,"name":4,"fn":5,"description":6,"org":7,"tags":11,"stars":23,"repoUrl":24,"updatedAt":25,"license":26,"forks":27,"topics":28,"repo":32,"sourceUrl":35,"mdContent":36},"should-flag-change","evaluate code changes for feature flagging","Decide whether a given code change should be placed behind a LaunchDarkly feature flag. Use when a developer asks whether a change should be behind a flag, when reviewing a diff or pull request, or when running in CI on a PR. Reads the diff and surrounding code, then emits a structured advisory recommendation. Read-only: it never creates or modifies flags.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},"launchdarkly","LaunchDarkly","https:\u002F\u002Fpexgzepcugksgbtrxkhf.supabase.co\u002Fstorage\u002Fv1\u002Fobject\u002Fpublic\u002Forg-logos\u002Flaunchdarkly.png",[12,16,19,22],{"name":13,"slug":14,"type":15},"Security","security","tag",{"name":17,"slug":18,"type":15},"Feature Flags","feature-flags",{"name":20,"slug":21,"type":15},"Code Review","code-review",{"name":9,"slug":8,"type":15},20,"https:\u002F\u002Fgithub.com\u002Flaunchdarkly\u002Fai-tooling","2026-07-24T06:08:57.498551","Apache-2.0",6,[29,30,31],"agent-skills","launchdarkly-ai","managed-by-terraform",{"repoUrl":24,"stars":23,"forks":27,"topics":33,"description":34},[29,30,31],"LaunchDarkly's official AI tooling","https:\u002F\u002Fgithub.com\u002Flaunchdarkly\u002Fai-tooling\u002Ftree\u002FHEAD\u002Fskills\u002Ffeature-flags\u002Fshould-flag-change","---\nname: should-flag-change\ndescription: \"Decide whether a given code change should be placed behind a LaunchDarkly feature flag. Use when a developer asks whether a change should be behind a flag, when reviewing a diff or pull request, or when running in CI on a PR. Reads the diff and surrounding code, then emits a structured advisory recommendation. Read-only: it never creates or modifies flags.\"\nlicense: Apache-2.0\ncompatibility: \"Advisory and read-only. Works on all platforms. Does NOT require the LaunchDarkly MCP server. Reads code with standard file tools (Read\u002FGrep\u002FGlob) and returns a structured verdict via the `recommend-flag` tool.\"\nmetadata:\n  author: launchdarkly\n  version: \"0.2.0-experimental\"\n---\n\n# Should This Change Be Behind a Flag?\n\nYou're using a skill that gives an **advisory** recommendation on whether a code change should be released behind a LaunchDarkly feature flag. Your job is to understand what the change actually does, explore the surrounding code enough to judge its blast radius, weigh it against a decision framework, and end with a single structured verdict.\n\nYou are invoked two ways:\n\n1. **Ad hoc** — a developer asks \"should this be behind a flag?\" about work in progress.\n2. **In CI on a pull request** — you are fed a git diff (in a `\u003Cgit_diff>` block) and can read the surrounding source. Your verdict is parsed to post a check on the PR.\n\nBoth paths end the same way: a call to the `recommend-flag` tool.\n\n## Scope Boundary\n\nThis skill is **read-only and advisory**. You produce a recommendation; you never act on it.\n\n**Hard constraints — you MUST NOT:**\n\n- Create, toggle, update, archive, or delete any feature flag.\n- Call any flag-mutating MCP tool (`create-flag`, `create-feature-flag`, `update-flag-settings`, `update-feature-flag`, `toggle-flag`, `delete-flag`, or similar).\n- Modify, stage, or commit code. You read; you do not write.\n- Instruct the user to run a command that mutates flags as if it were part of this workflow.\n\nIf the developer wants to actually create the flag after your recommendation, route them to the **flag create** skill. Do not do it yourself.\n\n## Core Principles\n\n1. **Advisory, not authoritative.** You inform a human decision. Be clear and specific; do not gate the merge.\n2. **False negatives are worse than false positives.** Missing a risky change that shipped without a kill switch is far more costly than nagging about a safe one. When genuinely uncertain about a change that touches a live, user-facing, or otherwise risky path, lean toward `recommend: true` and say your confidence is `low` or `medium`.\n3. **Explore before deciding.** A diff shows *what* lines changed, not *what they mean*. Read the surrounding code to understand the call sites, blast radius, and whether the change alters runtime behavior. In CI you have the repo tree — use it.\n4. **Judge behavior, not line count.** A one-line change to an auth check matters more than a 500-line rename. Ask \"does this change what production does, and for whom?\"\n5. **Cite evidence.** Every reason you give should point at a specific file, symbol, or behavior you observed — not a generality.\n\n## Workflow\n\n### Step 1: Understand the change\n\nRead the `\u003Cgit_diff>` block (or the diff\u002Fdescription the developer provided). Establish:\n\n- **What files and layers changed** — routing\u002Fcontrollers, business logic, data access, config, tests, docs, build.\n- **Whether behavior changes at runtime** — new code path, altered branch, changed default, new external call — versus a behavior-preserving transformation (rename, extraction, formatting).\n- **Who is affected** — an end-user-facing path, an internal tool, a background job, or nothing at runtime.\n\n### Step 2: Explore the surrounding code\n\nBefore deciding, use `Read`, `Grep`, and `Glob` to answer the questions the diff alone can't:\n\n1. **Call sites and blast radius.** Grep for the changed function\u002Fendpoint. How many callers? Is it on a hot or critical path?\n2. **Existing flag conventions.** Does this codebase already gate similar changes behind flags? Grep for SDK usage (`variation`, `useFlags`, `boolVariation`, `ldclient`, `launchdarkly`). A change that mirrors an already-flagged pattern is a strong signal.\n3. **Ancestor gate — is it already behind a flag?** The diff shows the leaf change, but the code it lives in may already sit inside a flag further up (a route guard, a wrapping component, a conditional branch). Walk up from the changed lines to the nearest enclosing flag check. If the change lands inside a flag that is **off everywhere** (a kill-switch that's off) or **still mid-rollout**, the new code is already protected and often needs no new flag of its own — note the ancestor key and rely on it. If the ancestor is **fully launched** (100%, no longer protecting) or is a **permanent config\u002Fentitlement gate** (not a rollout flag), treat the change as effectively unguarded and apply the framework normally. If you can't resolve the ancestor's rollout state from what's in front of you, say so and lower confidence.\n4. **Migration state.** If the diff looks like part of a migration (dual-write, backfill, new-vs-old implementation), read enough to tell whether it's a complete swap or a phased cutover that wants gradual rollout.\n5. **Safety of the change.** For risky-looking edits (auth, permissions, payments, data writes, rate limits), confirm from the surrounding code whether the change is additive\u002Fguarded or a direct behavior change to a live path.\n6. **Dependencies on other features.** Check whether the new path calls into a capability that itself looks flag-gated or not yet released. If this change must not go live before that parent capability, note the dependency in your reasons — it's a reason to flag (so the two releases can be coupled via a prerequisite).\n\nSkip exploration only when the change is unambiguous on its face (e.g. a docs-only or test-only diff) — and say so in your reasons.\n\n### Step 3: Assess against the decision framework\n\n**The user-observability test — apply before any `recommend: false`.** Before you land on \"no flag,\" answer one question: **would a user on any live, unguarded path experience a difference from this change?** If yes — and the code is not already behind an off\u002Fmid-rollout ancestor gate — it is **not** a free skip; treat it as at least Ambiguous and pick a side deliberately. The phrases that most often mask a missed flag are **\"low-risk bug fix,\" \"visual polish,\" and \"purely additive\"** — none of them, on its own, makes a change skippable:\n\n- **\"Additive\" is not \"safe.\"** A newly-shown panel, a new row, a now-populated dropdown, or a newly-surfaced suggestion is still a user-visible behavior change that can regress.\n- **A default-value change is flag-worthy even at one line.** If a control now opens\u002Fsorts\u002Floads differently by default, a user experiences it without opting in.\n- **\"Low-risk bug fix\" only skips when the fix is invisible to users.** A fix that changes what a user experiences on a live, unprotected path is a behavior change; size and intent don't downgrade it.\n\n**Recommend a flag (`recommend: true`) when the change:**\n\n| Signal | Why it wants a flag |\n|--------|---------------------|\n| Introduces a **new user-facing path** (endpoint, screen, flow, feature) | Gradual rollout + kill switch de-risk exposure to real users |\n| **Changes behavior on a live production path** (auth, payments, permissions, data writes, pricing, rate limits) | High blast radius; you want an instant off-switch |\n| Is an **incomplete or phased migration** (dual-write, backfill, cutover between old\u002Fnew implementations) | Rollout control lets you shift traffic and roll back per-cohort |\n| Is **performance-sensitive** or touches a hot path where regressions are likely | Fast rollback without a redeploy |\n| Alters a **critical \u002F high-blast-radius** subsystem many callers depend on | Contain the blast radius during rollout |\n| **Depends on another not-yet-live feature or flag** (must not go live before a parent capability) | A flag lets you couple this release to the parent's — via a prerequisite — instead of shipping it live prematurely |\n\n**Do not recommend a flag (`recommend: false`) when the change is:**\n\n| Signal | Why a flag adds no value |\n|--------|--------------------------|\n| A **pure refactor** with no behavior change (rename, extract, move, reformat) | Nothing to roll out; flag adds dead complexity |\n| **Test-only** (new\u002Fupdated tests, fixtures, mocks) | Not shipped to users |\n| **Docs \u002F comments \u002F README** | No runtime behavior |\n| A **dependency bump** with no behavior change at your call sites | (Caveat below) |\n| An **internal rename** or mechanical\u002Fcodegen change | Behavior-preserving |\n| **Build, CI, or tooling** config that doesn't affect runtime | Not a user-facing behavior change |\n\n**Ambiguous — judge on the merits and explain the tradeoff:**\n\n- **Refactor that also changes business logic or an API contract** — not a pure refactor. If the \"cleanup\" quietly alters what a call returns or how a path behaves, treat it as a behavior change and lean toward a flag.\n- **Bug fixes to an existing path** — flagging lets you compare old vs. fixed behavior, but a clear correctness fix is often just shipped. Decide based on blast radius and reversibility.\n- **Dependency bumps that do change runtime behavior** (major version, changed defaults) — lean toward a flag if the behavior delta reaches a live path.\n- **Small behavior tweaks** to an existing feature — weigh reversibility and who's affected.\n\nFor ambiguous cases, pick the defensible side and make your reasons show that you weighed both directions. Honor the false-negative-over-false-positive principle when the ambiguous change touches a risky or user-facing path. **Any change that falls in this Ambiguous table MUST NOT be reported with `high` confidence** — an honestly borderline call is `low` or `medium` by definition, regardless of which verdict you land on.\n\n### Decision posture (tie-breaker for genuinely balanced cases)\n\nThe user-observability test and the false-negative-over-false-positive principle come first. When they don't settle it — the change is truly balanced with no dominant signal — the tie-breaker depends on the team's release posture. State which posture you applied so the call is auditable.\n\n- **Conservative (default, human-in-the-loop):** an extra flag costs review, registry churn, and cleanup debt, so a genuinely balanced change → lean `recommend: false` and route it to tests\u002Freview.\n- **Low-overhead (automated release and automated flag cleanup are in place):** the cost of an extra flag is near zero while a missed flag ships unguarded to users, so a genuinely balanced **customer-visible** change → lean `recommend: true`.\n\nAbsent any signal about the team's setup, assume the conservative posture. This tie-breaker only applies to the last-mile balanced call; it never overrides the user-observability test or a clear risk\u002Fuser-facing signal.\n\n### Step 4: Emit the verdict\n\nEnd by calling the **`recommend-flag`** tool exactly once, with your structured recommendation. This is the deliverable — CI parses it to post the PR check, and it is the last thing you do.\n\n```\nrecommend-flag({\n  recommend: boolean,            \u002F\u002F true = should be behind a flag\n  verdict: \"suggested\" | \"already-flagged\" | \"not-suited\",  \u002F\u002F the specific outcome; see below\n  confidence: \"low\" | \"medium\" | \"high\",\n  risk: \"low\" | \"medium\" | \"high\",  \u002F\u002F optional: blast radius \u002F severity of the change itself\n  reasons: [                     \u002F\u002F concise, evidence-based; each cites a file\u002Fbehavior\n    \"New public endpoint POST \u002Fexport added in src\u002Froutes\u002Fexport.ts — user-facing path with no existing gate\",\n    \"No LaunchDarkly usage found near the new route (grepped src\u002Froutes) — this would ship unguarded\"\n  ]\n})\n```\n\nRules for the verdict:\n\n- **Call the tool exactly once, as the final step.** Do not call it before you've explored.\n- **`reasons` must be specific and evidence-based.** Reference the files, symbols, or behaviors you actually observed. Avoid generic statements like \"this is risky.\"\n- **Set `verdict` to the specific outcome — keep `already-flagged` distinct from `not-suited`.** `recommend: true` always pairs with `verdict: \"suggested\"`. `recommend: false` splits into two outcomes that must not be collapsed into one \"no flag\" bucket:\n  - `already-flagged` — the change is *already protected*: it ships behind a flag check in the diff, or it lives inside an off \u002F mid-rollout ancestor gate. There **is** a flag; it just isn't a *new* one. Name the flag key (and, for an ancestor, its rollout state) in `reasons`.\n  - `not-suited` — there is *genuinely nothing to flag*: a pure refactor, docs\u002Fcomments, tests, dependency bump, or build\u002FCI\u002Ftooling change with no user-observable behavior change.\n\n  `recommend` stays the boolean a CI check keys on; `verdict` is the finer signal a dashboard uses to track flag coverage. Collapsing `already-flagged` into `not-suited` hides real coverage and inflates the apparent \"nothing to flag\" rate — a change protected by an ancestor gate is *covered*, not *unneeded*.\n- **Calibrate `confidence` — do not default to `high`.** Reserve `high` for genuinely clear-cut changes you fully understand (a docs-only diff, an obvious pure refactor, a plainly new user-facing endpoint). Use `medium` when the verdict is sound but you couldn't verify every call site, and `low` when the change is ambiguous, borderline, or touches money\u002Fsecurity\u002Fdata on a live path where reasonable reviewers could disagree. **If you weighed both directions in Step 3 — i.e. the change is in the Ambiguous table — `confidence` MUST be `low` or `medium`, never `high`, even when you land firmly on a verdict.** Confidence is about how clear-cut the *call* is, not how strongly you hold your conclusion. **Any reason you could not verify against the actual code caps `confidence` at `medium`, and you must name it as unverified.**\n- **Set `risk` (optional but recommended) to the change's blast radius — separate from `confidence`.** Confidence is how clear-cut the call is; risk is how much damage the change could do. They're orthogonal: a plainly-new-endpoint is a clear call (`high` confidence) that might be low blast radius, while an auth-fallthrough tweak can be both `high` confidence and `high` risk. Anchor it: `low` = small, additive, isolated change; `medium` = modified business logic \u002F moderate blast radius; `high` = cross-cutting, API-contract, data-migration, or auth\u002Fpayments\u002Fdata-integrity change. A downstream check can use `risk` to prioritize.\n- **Then summarize in prose** for the human: restate the verdict, the key reasons, and — if you recommended a flag — a one-line suggestion of what kind (e.g. \"a boolean release flag defaulting to the old behavior\"). Note whether the change is a **net-new path** (the flag-off control renders nothing, so a guarded rollout must lean on existing global\u002Fservice metrics — feature-specific before\u002Fafter comparisons are one-armed) or an **incremental change to a live path** (both variations exercise comparable code, so feature-specific metrics compare cleanly); this tells the release step what its rollout can actually measure. Point them at the flag create skill to actually create it. If the flag you're suggesting will **target** (a rule, individual target, or percentage rollout) rather than being a plain on\u002Foff switch, also point them at [Context Availability](..\u002Flaunchdarkly-flag-targeting\u002Freferences\u002Fcontext-availability.md) so the targeting names a context kind\u002Fattribute that actually exists where the flag is read.\n\nIf the `recommend-flag` tool is not available in your environment, emit the exact same object as a fenced ` ```json ` block labeled `recommend-flag` so it can still be parsed, then give the prose summary.\n\n## Edge Cases\n\n| Situation | Action |\n|-----------|--------|\n| Diff is empty or only whitespace | `recommend: false`, `verdict: not-suited`, `confidence: high`, reason noting no behavioral change |\n| Diff mixes a refactor with a real behavior change | Judge on the behavior change; recommend a flag if that part warrants it (`verdict: suggested`), and say which part drove the verdict |\n| Change is already behind a flag — in the diff, or an ancestor gate that's off\u002Fmid-rollout | `recommend: false`, `verdict: already-flagged`; name the flag key and, for an ancestor, its rollout state. If the ancestor is fully launched or a permanent config gate, it isn't protecting this change — judge normally (likely `verdict: suggested`). |\n| You can't read the surrounding code (no repo access, ad hoc snippet) | Decide from the diff alone; lower `confidence` and say exploration was unavailable |\n| The change is a hotfix \u002F revert | Usually `recommend: false` unless it re-introduces a risky path; explain |\n\n## What NOT to Do\n\n- **Don't create, toggle, or modify any flag.** You are advisory. See the Scope Boundary.\n- **Don't gate the merge or speak as a required check** — frame the output as a recommendation.\n- **Don't decide from the diff alone when you could read the code.** Line-level diffs hide blast radius.\n- **Don't be vague.** \"Might be risky\" is not a reason; \"changes the auth fallthrough in `middleware\u002Fauth.ts:42` which every route depends on\" is.\n- **Don't skip the `recommend-flag` call.** Prose without the structured verdict is not a usable result.\n- **Don't collapse `already-flagged` into `not-suited`.** A change protected by an ancestor gate is *covered*, not *nothing to flag* — record the two distinctly.\n- **Don't over-flag trivial changes.** Recommending a flag for a README edit erodes trust in the recommendation.\n",{"data":38,"body":42},{"name":4,"description":6,"license":26,"compatibility":39,"metadata":40},"Advisory and read-only. Works on all platforms. Does NOT require the LaunchDarkly MCP server. Reads code with standard file tools (Read\u002FGrep\u002FGlob) and returns a structured verdict via the `recommend-flag` tool.",{"author":8,"version":41},"0.2.0-experimental",{"type":43,"children":44},"root",[45,54,68,73,107,120,127,139,147,215,227,233,325,331,338,350,383,389,417,543,548,554,592,625,640,784,799,931,939,982,1015,1021,1026,1069,1074,1080,1095,1107,1112,1516,1543,1549,1696,1702],{"type":46,"tag":47,"props":48,"children":50},"element","h1",{"id":49},"should-this-change-be-behind-a-flag",[51],{"type":52,"value":53},"text","Should This Change Be Behind a Flag?",{"type":46,"tag":55,"props":56,"children":57},"p",{},[58,60,66],{"type":52,"value":59},"You're using a skill that gives an ",{"type":46,"tag":61,"props":62,"children":63},"strong",{},[64],{"type":52,"value":65},"advisory",{"type":52,"value":67}," recommendation on whether a code change should be released behind a LaunchDarkly feature flag. Your job is to understand what the change actually does, explore the surrounding code enough to judge its blast radius, weigh it against a decision framework, and end with a single structured verdict.",{"type":46,"tag":55,"props":69,"children":70},{},[71],{"type":52,"value":72},"You are invoked two ways:",{"type":46,"tag":74,"props":75,"children":76},"ol",{},[77,88],{"type":46,"tag":78,"props":79,"children":80},"li",{},[81,86],{"type":46,"tag":61,"props":82,"children":83},{},[84],{"type":52,"value":85},"Ad hoc",{"type":52,"value":87}," — a developer asks \"should this be behind a flag?\" about work in progress.",{"type":46,"tag":78,"props":89,"children":90},{},[91,96,98,105],{"type":46,"tag":61,"props":92,"children":93},{},[94],{"type":52,"value":95},"In CI on a pull request",{"type":52,"value":97}," — you are fed a git diff (in a ",{"type":46,"tag":99,"props":100,"children":102},"code",{"className":101},[],[103],{"type":52,"value":104},"\u003Cgit_diff>",{"type":52,"value":106}," block) and can read the surrounding source. Your verdict is parsed to post a check on the PR.",{"type":46,"tag":55,"props":108,"children":109},{},[110,112,118],{"type":52,"value":111},"Both paths end the same way: a call to the ",{"type":46,"tag":99,"props":113,"children":115},{"className":114},[],[116],{"type":52,"value":117},"recommend-flag",{"type":52,"value":119}," tool.",{"type":46,"tag":121,"props":122,"children":124},"h2",{"id":123},"scope-boundary",[125],{"type":52,"value":126},"Scope Boundary",{"type":46,"tag":55,"props":128,"children":129},{},[130,132,137],{"type":52,"value":131},"This skill is ",{"type":46,"tag":61,"props":133,"children":134},{},[135],{"type":52,"value":136},"read-only and advisory",{"type":52,"value":138},". You produce a recommendation; you never act on it.",{"type":46,"tag":55,"props":140,"children":141},{},[142],{"type":46,"tag":61,"props":143,"children":144},{},[145],{"type":52,"value":146},"Hard constraints — you MUST NOT:",{"type":46,"tag":148,"props":149,"children":150},"ul",{},[151,156,205,210],{"type":46,"tag":78,"props":152,"children":153},{},[154],{"type":52,"value":155},"Create, toggle, update, archive, or delete any feature flag.",{"type":46,"tag":78,"props":157,"children":158},{},[159,161,167,169,175,176,182,183,189,190,196,197,203],{"type":52,"value":160},"Call any flag-mutating MCP tool (",{"type":46,"tag":99,"props":162,"children":164},{"className":163},[],[165],{"type":52,"value":166},"create-flag",{"type":52,"value":168},", ",{"type":46,"tag":99,"props":170,"children":172},{"className":171},[],[173],{"type":52,"value":174},"create-feature-flag",{"type":52,"value":168},{"type":46,"tag":99,"props":177,"children":179},{"className":178},[],[180],{"type":52,"value":181},"update-flag-settings",{"type":52,"value":168},{"type":46,"tag":99,"props":184,"children":186},{"className":185},[],[187],{"type":52,"value":188},"update-feature-flag",{"type":52,"value":168},{"type":46,"tag":99,"props":191,"children":193},{"className":192},[],[194],{"type":52,"value":195},"toggle-flag",{"type":52,"value":168},{"type":46,"tag":99,"props":198,"children":200},{"className":199},[],[201],{"type":52,"value":202},"delete-flag",{"type":52,"value":204},", or similar).",{"type":46,"tag":78,"props":206,"children":207},{},[208],{"type":52,"value":209},"Modify, stage, or commit code. You read; you do not write.",{"type":46,"tag":78,"props":211,"children":212},{},[213],{"type":52,"value":214},"Instruct the user to run a command that mutates flags as if it were part of this workflow.",{"type":46,"tag":55,"props":216,"children":217},{},[218,220,225],{"type":52,"value":219},"If the developer wants to actually create the flag after your recommendation, route them to the ",{"type":46,"tag":61,"props":221,"children":222},{},[223],{"type":52,"value":224},"flag create",{"type":52,"value":226}," skill. Do not do it yourself.",{"type":46,"tag":121,"props":228,"children":230},{"id":229},"core-principles",[231],{"type":52,"value":232},"Core Principles",{"type":46,"tag":74,"props":234,"children":235},{},[236,246,280,305,315],{"type":46,"tag":78,"props":237,"children":238},{},[239,244],{"type":46,"tag":61,"props":240,"children":241},{},[242],{"type":52,"value":243},"Advisory, not authoritative.",{"type":52,"value":245}," You inform a human decision. Be clear and specific; do not gate the merge.",{"type":46,"tag":78,"props":247,"children":248},{},[249,254,256,262,264,270,272,278],{"type":46,"tag":61,"props":250,"children":251},{},[252],{"type":52,"value":253},"False negatives are worse than false positives.",{"type":52,"value":255}," Missing a risky change that shipped without a kill switch is far more costly than nagging about a safe one. When genuinely uncertain about a change that touches a live, user-facing, or otherwise risky path, lean toward ",{"type":46,"tag":99,"props":257,"children":259},{"className":258},[],[260],{"type":52,"value":261},"recommend: true",{"type":52,"value":263}," and say your confidence is ",{"type":46,"tag":99,"props":265,"children":267},{"className":266},[],[268],{"type":52,"value":269},"low",{"type":52,"value":271}," or ",{"type":46,"tag":99,"props":273,"children":275},{"className":274},[],[276],{"type":52,"value":277},"medium",{"type":52,"value":279},".",{"type":46,"tag":78,"props":281,"children":282},{},[283,288,290,296,298,303],{"type":46,"tag":61,"props":284,"children":285},{},[286],{"type":52,"value":287},"Explore before deciding.",{"type":52,"value":289}," A diff shows ",{"type":46,"tag":291,"props":292,"children":293},"em",{},[294],{"type":52,"value":295},"what",{"type":52,"value":297}," lines changed, not ",{"type":46,"tag":291,"props":299,"children":300},{},[301],{"type":52,"value":302},"what they mean",{"type":52,"value":304},". Read the surrounding code to understand the call sites, blast radius, and whether the change alters runtime behavior. In CI you have the repo tree — use it.",{"type":46,"tag":78,"props":306,"children":307},{},[308,313],{"type":46,"tag":61,"props":309,"children":310},{},[311],{"type":52,"value":312},"Judge behavior, not line count.",{"type":52,"value":314}," A one-line change to an auth check matters more than a 500-line rename. Ask \"does this change what production does, and for whom?\"",{"type":46,"tag":78,"props":316,"children":317},{},[318,323],{"type":46,"tag":61,"props":319,"children":320},{},[321],{"type":52,"value":322},"Cite evidence.",{"type":52,"value":324}," Every reason you give should point at a specific file, symbol, or behavior you observed — not a generality.",{"type":46,"tag":121,"props":326,"children":328},{"id":327},"workflow",[329],{"type":52,"value":330},"Workflow",{"type":46,"tag":332,"props":333,"children":335},"h3",{"id":334},"step-1-understand-the-change",[336],{"type":52,"value":337},"Step 1: Understand the change",{"type":46,"tag":55,"props":339,"children":340},{},[341,343,348],{"type":52,"value":342},"Read the ",{"type":46,"tag":99,"props":344,"children":346},{"className":345},[],[347],{"type":52,"value":104},{"type":52,"value":349}," block (or the diff\u002Fdescription the developer provided). Establish:",{"type":46,"tag":148,"props":351,"children":352},{},[353,363,373],{"type":46,"tag":78,"props":354,"children":355},{},[356,361],{"type":46,"tag":61,"props":357,"children":358},{},[359],{"type":52,"value":360},"What files and layers changed",{"type":52,"value":362}," — routing\u002Fcontrollers, business logic, data access, config, tests, docs, build.",{"type":46,"tag":78,"props":364,"children":365},{},[366,371],{"type":46,"tag":61,"props":367,"children":368},{},[369],{"type":52,"value":370},"Whether behavior changes at runtime",{"type":52,"value":372}," — new code path, altered branch, changed default, new external call — versus a behavior-preserving transformation (rename, extraction, formatting).",{"type":46,"tag":78,"props":374,"children":375},{},[376,381],{"type":46,"tag":61,"props":377,"children":378},{},[379],{"type":52,"value":380},"Who is affected",{"type":52,"value":382}," — an end-user-facing path, an internal tool, a background job, or nothing at runtime.",{"type":46,"tag":332,"props":384,"children":386},{"id":385},"step-2-explore-the-surrounding-code",[387],{"type":52,"value":388},"Step 2: Explore the surrounding code",{"type":46,"tag":55,"props":390,"children":391},{},[392,394,400,401,407,409,415],{"type":52,"value":393},"Before deciding, use ",{"type":46,"tag":99,"props":395,"children":397},{"className":396},[],[398],{"type":52,"value":399},"Read",{"type":52,"value":168},{"type":46,"tag":99,"props":402,"children":404},{"className":403},[],[405],{"type":52,"value":406},"Grep",{"type":52,"value":408},", and ",{"type":46,"tag":99,"props":410,"children":412},{"className":411},[],[413],{"type":52,"value":414},"Glob",{"type":52,"value":416}," to answer the questions the diff alone can't:",{"type":46,"tag":74,"props":418,"children":419},{},[420,430,475,513,523,533],{"type":46,"tag":78,"props":421,"children":422},{},[423,428],{"type":46,"tag":61,"props":424,"children":425},{},[426],{"type":52,"value":427},"Call sites and blast radius.",{"type":52,"value":429}," Grep for the changed function\u002Fendpoint. How many callers? Is it on a hot or critical path?",{"type":46,"tag":78,"props":431,"children":432},{},[433,438,440,446,447,453,454,460,461,467,468,473],{"type":46,"tag":61,"props":434,"children":435},{},[436],{"type":52,"value":437},"Existing flag conventions.",{"type":52,"value":439}," Does this codebase already gate similar changes behind flags? Grep for SDK usage (",{"type":46,"tag":99,"props":441,"children":443},{"className":442},[],[444],{"type":52,"value":445},"variation",{"type":52,"value":168},{"type":46,"tag":99,"props":448,"children":450},{"className":449},[],[451],{"type":52,"value":452},"useFlags",{"type":52,"value":168},{"type":46,"tag":99,"props":455,"children":457},{"className":456},[],[458],{"type":52,"value":459},"boolVariation",{"type":52,"value":168},{"type":46,"tag":99,"props":462,"children":464},{"className":463},[],[465],{"type":52,"value":466},"ldclient",{"type":52,"value":168},{"type":46,"tag":99,"props":469,"children":471},{"className":470},[],[472],{"type":52,"value":8},{"type":52,"value":474},"). A change that mirrors an already-flagged pattern is a strong signal.",{"type":46,"tag":78,"props":476,"children":477},{},[478,483,485,490,492,497,499,504,506,511],{"type":46,"tag":61,"props":479,"children":480},{},[481],{"type":52,"value":482},"Ancestor gate — is it already behind a flag?",{"type":52,"value":484}," The diff shows the leaf change, but the code it lives in may already sit inside a flag further up (a route guard, a wrapping component, a conditional branch). Walk up from the changed lines to the nearest enclosing flag check. If the change lands inside a flag that is ",{"type":46,"tag":61,"props":486,"children":487},{},[488],{"type":52,"value":489},"off everywhere",{"type":52,"value":491}," (a kill-switch that's off) or ",{"type":46,"tag":61,"props":493,"children":494},{},[495],{"type":52,"value":496},"still mid-rollout",{"type":52,"value":498},", the new code is already protected and often needs no new flag of its own — note the ancestor key and rely on it. If the ancestor is ",{"type":46,"tag":61,"props":500,"children":501},{},[502],{"type":52,"value":503},"fully launched",{"type":52,"value":505}," (100%, no longer protecting) or is a ",{"type":46,"tag":61,"props":507,"children":508},{},[509],{"type":52,"value":510},"permanent config\u002Fentitlement gate",{"type":52,"value":512}," (not a rollout flag), treat the change as effectively unguarded and apply the framework normally. If you can't resolve the ancestor's rollout state from what's in front of you, say so and lower confidence.",{"type":46,"tag":78,"props":514,"children":515},{},[516,521],{"type":46,"tag":61,"props":517,"children":518},{},[519],{"type":52,"value":520},"Migration state.",{"type":52,"value":522}," If the diff looks like part of a migration (dual-write, backfill, new-vs-old implementation), read enough to tell whether it's a complete swap or a phased cutover that wants gradual rollout.",{"type":46,"tag":78,"props":524,"children":525},{},[526,531],{"type":46,"tag":61,"props":527,"children":528},{},[529],{"type":52,"value":530},"Safety of the change.",{"type":52,"value":532}," For risky-looking edits (auth, permissions, payments, data writes, rate limits), confirm from the surrounding code whether the change is additive\u002Fguarded or a direct behavior change to a live path.",{"type":46,"tag":78,"props":534,"children":535},{},[536,541],{"type":46,"tag":61,"props":537,"children":538},{},[539],{"type":52,"value":540},"Dependencies on other features.",{"type":52,"value":542}," Check whether the new path calls into a capability that itself looks flag-gated or not yet released. If this change must not go live before that parent capability, note the dependency in your reasons — it's a reason to flag (so the two releases can be coupled via a prerequisite).",{"type":46,"tag":55,"props":544,"children":545},{},[546],{"type":52,"value":547},"Skip exploration only when the change is unambiguous on its face (e.g. a docs-only or test-only diff) — and say so in your reasons.",{"type":46,"tag":332,"props":549,"children":551},{"id":550},"step-3-assess-against-the-decision-framework",[552],{"type":52,"value":553},"Step 3: Assess against the decision framework",{"type":46,"tag":55,"props":555,"children":556},{},[557,569,571,576,578,583,585,590],{"type":46,"tag":61,"props":558,"children":559},{},[560,562,568],{"type":52,"value":561},"The user-observability test — apply before any ",{"type":46,"tag":99,"props":563,"children":565},{"className":564},[],[566],{"type":52,"value":567},"recommend: false",{"type":52,"value":279},{"type":52,"value":570}," Before you land on \"no flag,\" answer one question: ",{"type":46,"tag":61,"props":572,"children":573},{},[574],{"type":52,"value":575},"would a user on any live, unguarded path experience a difference from this change?",{"type":52,"value":577}," If yes — and the code is not already behind an off\u002Fmid-rollout ancestor gate — it is ",{"type":46,"tag":61,"props":579,"children":580},{},[581],{"type":52,"value":582},"not",{"type":52,"value":584}," a free skip; treat it as at least Ambiguous and pick a side deliberately. The phrases that most often mask a missed flag are ",{"type":46,"tag":61,"props":586,"children":587},{},[588],{"type":52,"value":589},"\"low-risk bug fix,\" \"visual polish,\" and \"purely additive\"",{"type":52,"value":591}," — none of them, on its own, makes a change skippable:",{"type":46,"tag":148,"props":593,"children":594},{},[595,605,615],{"type":46,"tag":78,"props":596,"children":597},{},[598,603],{"type":46,"tag":61,"props":599,"children":600},{},[601],{"type":52,"value":602},"\"Additive\" is not \"safe.\"",{"type":52,"value":604}," A newly-shown panel, a new row, a now-populated dropdown, or a newly-surfaced suggestion is still a user-visible behavior change that can regress.",{"type":46,"tag":78,"props":606,"children":607},{},[608,613],{"type":46,"tag":61,"props":609,"children":610},{},[611],{"type":52,"value":612},"A default-value change is flag-worthy even at one line.",{"type":52,"value":614}," If a control now opens\u002Fsorts\u002Floads differently by default, a user experiences it without opting in.",{"type":46,"tag":78,"props":616,"children":617},{},[618,623],{"type":46,"tag":61,"props":619,"children":620},{},[621],{"type":52,"value":622},"\"Low-risk bug fix\" only skips when the fix is invisible to users.",{"type":52,"value":624}," A fix that changes what a user experiences on a live, unprotected path is a behavior change; size and intent don't downgrade it.",{"type":46,"tag":55,"props":626,"children":627},{},[628],{"type":46,"tag":61,"props":629,"children":630},{},[631,633,638],{"type":52,"value":632},"Recommend a flag (",{"type":46,"tag":99,"props":634,"children":636},{"className":635},[],[637],{"type":52,"value":261},{"type":52,"value":639},") when the change:",{"type":46,"tag":641,"props":642,"children":643},"table",{},[644,663],{"type":46,"tag":645,"props":646,"children":647},"thead",{},[648],{"type":46,"tag":649,"props":650,"children":651},"tr",{},[652,658],{"type":46,"tag":653,"props":654,"children":655},"th",{},[656],{"type":52,"value":657},"Signal",{"type":46,"tag":653,"props":659,"children":660},{},[661],{"type":52,"value":662},"Why it wants a flag",{"type":46,"tag":664,"props":665,"children":666},"tbody",{},[667,688,706,726,746,766],{"type":46,"tag":649,"props":668,"children":669},{},[670,683],{"type":46,"tag":671,"props":672,"children":673},"td",{},[674,676,681],{"type":52,"value":675},"Introduces a ",{"type":46,"tag":61,"props":677,"children":678},{},[679],{"type":52,"value":680},"new user-facing path",{"type":52,"value":682}," (endpoint, screen, flow, feature)",{"type":46,"tag":671,"props":684,"children":685},{},[686],{"type":52,"value":687},"Gradual rollout + kill switch de-risk exposure to real users",{"type":46,"tag":649,"props":689,"children":690},{},[691,701],{"type":46,"tag":671,"props":692,"children":693},{},[694,699],{"type":46,"tag":61,"props":695,"children":696},{},[697],{"type":52,"value":698},"Changes behavior on a live production path",{"type":52,"value":700}," (auth, payments, permissions, data writes, pricing, rate limits)",{"type":46,"tag":671,"props":702,"children":703},{},[704],{"type":52,"value":705},"High blast radius; you want an instant off-switch",{"type":46,"tag":649,"props":707,"children":708},{},[709,721],{"type":46,"tag":671,"props":710,"children":711},{},[712,714,719],{"type":52,"value":713},"Is an ",{"type":46,"tag":61,"props":715,"children":716},{},[717],{"type":52,"value":718},"incomplete or phased migration",{"type":52,"value":720}," (dual-write, backfill, cutover between old\u002Fnew implementations)",{"type":46,"tag":671,"props":722,"children":723},{},[724],{"type":52,"value":725},"Rollout control lets you shift traffic and roll back per-cohort",{"type":46,"tag":649,"props":727,"children":728},{},[729,741],{"type":46,"tag":671,"props":730,"children":731},{},[732,734,739],{"type":52,"value":733},"Is ",{"type":46,"tag":61,"props":735,"children":736},{},[737],{"type":52,"value":738},"performance-sensitive",{"type":52,"value":740}," or touches a hot path where regressions are likely",{"type":46,"tag":671,"props":742,"children":743},{},[744],{"type":52,"value":745},"Fast rollback without a redeploy",{"type":46,"tag":649,"props":747,"children":748},{},[749,761],{"type":46,"tag":671,"props":750,"children":751},{},[752,754,759],{"type":52,"value":753},"Alters a ",{"type":46,"tag":61,"props":755,"children":756},{},[757],{"type":52,"value":758},"critical \u002F high-blast-radius",{"type":52,"value":760}," subsystem many callers depend on",{"type":46,"tag":671,"props":762,"children":763},{},[764],{"type":52,"value":765},"Contain the blast radius during rollout",{"type":46,"tag":649,"props":767,"children":768},{},[769,779],{"type":46,"tag":671,"props":770,"children":771},{},[772,777],{"type":46,"tag":61,"props":773,"children":774},{},[775],{"type":52,"value":776},"Depends on another not-yet-live feature or flag",{"type":52,"value":778}," (must not go live before a parent capability)",{"type":46,"tag":671,"props":780,"children":781},{},[782],{"type":52,"value":783},"A flag lets you couple this release to the parent's — via a prerequisite — instead of shipping it live prematurely",{"type":46,"tag":55,"props":785,"children":786},{},[787],{"type":46,"tag":61,"props":788,"children":789},{},[790,792,797],{"type":52,"value":791},"Do not recommend a flag (",{"type":46,"tag":99,"props":793,"children":795},{"className":794},[],[796],{"type":52,"value":567},{"type":52,"value":798},") when the change is:",{"type":46,"tag":641,"props":800,"children":801},{},[802,817],{"type":46,"tag":645,"props":803,"children":804},{},[805],{"type":46,"tag":649,"props":806,"children":807},{},[808,812],{"type":46,"tag":653,"props":809,"children":810},{},[811],{"type":52,"value":657},{"type":46,"tag":653,"props":813,"children":814},{},[815],{"type":52,"value":816},"Why a flag adds no value",{"type":46,"tag":664,"props":818,"children":819},{},[820,840,858,874,893,913],{"type":46,"tag":649,"props":821,"children":822},{},[823,835],{"type":46,"tag":671,"props":824,"children":825},{},[826,828,833],{"type":52,"value":827},"A ",{"type":46,"tag":61,"props":829,"children":830},{},[831],{"type":52,"value":832},"pure refactor",{"type":52,"value":834}," with no behavior change (rename, extract, move, reformat)",{"type":46,"tag":671,"props":836,"children":837},{},[838],{"type":52,"value":839},"Nothing to roll out; flag adds dead complexity",{"type":46,"tag":649,"props":841,"children":842},{},[843,853],{"type":46,"tag":671,"props":844,"children":845},{},[846,851],{"type":46,"tag":61,"props":847,"children":848},{},[849],{"type":52,"value":850},"Test-only",{"type":52,"value":852}," (new\u002Fupdated tests, fixtures, mocks)",{"type":46,"tag":671,"props":854,"children":855},{},[856],{"type":52,"value":857},"Not shipped to users",{"type":46,"tag":649,"props":859,"children":860},{},[861,869],{"type":46,"tag":671,"props":862,"children":863},{},[864],{"type":46,"tag":61,"props":865,"children":866},{},[867],{"type":52,"value":868},"Docs \u002F comments \u002F README",{"type":46,"tag":671,"props":870,"children":871},{},[872],{"type":52,"value":873},"No runtime behavior",{"type":46,"tag":649,"props":875,"children":876},{},[877,888],{"type":46,"tag":671,"props":878,"children":879},{},[880,881,886],{"type":52,"value":827},{"type":46,"tag":61,"props":882,"children":883},{},[884],{"type":52,"value":885},"dependency bump",{"type":52,"value":887}," with no behavior change at your call sites",{"type":46,"tag":671,"props":889,"children":890},{},[891],{"type":52,"value":892},"(Caveat below)",{"type":46,"tag":649,"props":894,"children":895},{},[896,908],{"type":46,"tag":671,"props":897,"children":898},{},[899,901,906],{"type":52,"value":900},"An ",{"type":46,"tag":61,"props":902,"children":903},{},[904],{"type":52,"value":905},"internal rename",{"type":52,"value":907}," or mechanical\u002Fcodegen change",{"type":46,"tag":671,"props":909,"children":910},{},[911],{"type":52,"value":912},"Behavior-preserving",{"type":46,"tag":649,"props":914,"children":915},{},[916,926],{"type":46,"tag":671,"props":917,"children":918},{},[919,924],{"type":46,"tag":61,"props":920,"children":921},{},[922],{"type":52,"value":923},"Build, CI, or tooling",{"type":52,"value":925}," config that doesn't affect runtime",{"type":46,"tag":671,"props":927,"children":928},{},[929],{"type":52,"value":930},"Not a user-facing behavior change",{"type":46,"tag":55,"props":932,"children":933},{},[934],{"type":46,"tag":61,"props":935,"children":936},{},[937],{"type":52,"value":938},"Ambiguous — judge on the merits and explain the tradeoff:",{"type":46,"tag":148,"props":940,"children":941},{},[942,952,962,972],{"type":46,"tag":78,"props":943,"children":944},{},[945,950],{"type":46,"tag":61,"props":946,"children":947},{},[948],{"type":52,"value":949},"Refactor that also changes business logic or an API contract",{"type":52,"value":951}," — not a pure refactor. If the \"cleanup\" quietly alters what a call returns or how a path behaves, treat it as a behavior change and lean toward a flag.",{"type":46,"tag":78,"props":953,"children":954},{},[955,960],{"type":46,"tag":61,"props":956,"children":957},{},[958],{"type":52,"value":959},"Bug fixes to an existing path",{"type":52,"value":961}," — flagging lets you compare old vs. fixed behavior, but a clear correctness fix is often just shipped. Decide based on blast radius and reversibility.",{"type":46,"tag":78,"props":963,"children":964},{},[965,970],{"type":46,"tag":61,"props":966,"children":967},{},[968],{"type":52,"value":969},"Dependency bumps that do change runtime behavior",{"type":52,"value":971}," (major version, changed defaults) — lean toward a flag if the behavior delta reaches a live path.",{"type":46,"tag":78,"props":973,"children":974},{},[975,980],{"type":46,"tag":61,"props":976,"children":977},{},[978],{"type":52,"value":979},"Small behavior tweaks",{"type":52,"value":981}," to an existing feature — weigh reversibility and who's affected.",{"type":46,"tag":55,"props":983,"children":984},{},[985,987,1000,1002,1007,1008,1013],{"type":52,"value":986},"For ambiguous cases, pick the defensible side and make your reasons show that you weighed both directions. Honor the false-negative-over-false-positive principle when the ambiguous change touches a risky or user-facing path. ",{"type":46,"tag":61,"props":988,"children":989},{},[990,992,998],{"type":52,"value":991},"Any change that falls in this Ambiguous table MUST NOT be reported with ",{"type":46,"tag":99,"props":993,"children":995},{"className":994},[],[996],{"type":52,"value":997},"high",{"type":52,"value":999}," confidence",{"type":52,"value":1001}," — an honestly borderline call is ",{"type":46,"tag":99,"props":1003,"children":1005},{"className":1004},[],[1006],{"type":52,"value":269},{"type":52,"value":271},{"type":46,"tag":99,"props":1009,"children":1011},{"className":1010},[],[1012],{"type":52,"value":277},{"type":52,"value":1014}," by definition, regardless of which verdict you land on.",{"type":46,"tag":332,"props":1016,"children":1018},{"id":1017},"decision-posture-tie-breaker-for-genuinely-balanced-cases",[1019],{"type":52,"value":1020},"Decision posture (tie-breaker for genuinely balanced cases)",{"type":46,"tag":55,"props":1022,"children":1023},{},[1024],{"type":52,"value":1025},"The user-observability test and the false-negative-over-false-positive principle come first. When they don't settle it — the change is truly balanced with no dominant signal — the tie-breaker depends on the team's release posture. State which posture you applied so the call is auditable.",{"type":46,"tag":148,"props":1027,"children":1028},{},[1029,1046],{"type":46,"tag":78,"props":1030,"children":1031},{},[1032,1037,1039,1044],{"type":46,"tag":61,"props":1033,"children":1034},{},[1035],{"type":52,"value":1036},"Conservative (default, human-in-the-loop):",{"type":52,"value":1038}," an extra flag costs review, registry churn, and cleanup debt, so a genuinely balanced change → lean ",{"type":46,"tag":99,"props":1040,"children":1042},{"className":1041},[],[1043],{"type":52,"value":567},{"type":52,"value":1045}," and route it to tests\u002Freview.",{"type":46,"tag":78,"props":1047,"children":1048},{},[1049,1054,1056,1061,1063,1068],{"type":46,"tag":61,"props":1050,"children":1051},{},[1052],{"type":52,"value":1053},"Low-overhead (automated release and automated flag cleanup are in place):",{"type":52,"value":1055}," the cost of an extra flag is near zero while a missed flag ships unguarded to users, so a genuinely balanced ",{"type":46,"tag":61,"props":1057,"children":1058},{},[1059],{"type":52,"value":1060},"customer-visible",{"type":52,"value":1062}," change → lean ",{"type":46,"tag":99,"props":1064,"children":1066},{"className":1065},[],[1067],{"type":52,"value":261},{"type":52,"value":279},{"type":46,"tag":55,"props":1070,"children":1071},{},[1072],{"type":52,"value":1073},"Absent any signal about the team's setup, assume the conservative posture. This tie-breaker only applies to the last-mile balanced call; it never overrides the user-observability test or a clear risk\u002Fuser-facing signal.",{"type":46,"tag":332,"props":1075,"children":1077},{"id":1076},"step-4-emit-the-verdict",[1078],{"type":52,"value":1079},"Step 4: Emit the verdict",{"type":46,"tag":55,"props":1081,"children":1082},{},[1083,1085,1093],{"type":52,"value":1084},"End by calling the ",{"type":46,"tag":61,"props":1086,"children":1087},{},[1088],{"type":46,"tag":99,"props":1089,"children":1091},{"className":1090},[],[1092],{"type":52,"value":117},{"type":52,"value":1094}," tool exactly once, with your structured recommendation. This is the deliverable — CI parses it to post the PR check, and it is the last thing you do.",{"type":46,"tag":1096,"props":1097,"children":1101},"pre",{"className":1098,"code":1100,"language":52},[1099],"language-text","recommend-flag({\n  recommend: boolean,            \u002F\u002F true = should be behind a flag\n  verdict: \"suggested\" | \"already-flagged\" | \"not-suited\",  \u002F\u002F the specific outcome; see below\n  confidence: \"low\" | \"medium\" | \"high\",\n  risk: \"low\" | \"medium\" | \"high\",  \u002F\u002F optional: blast radius \u002F severity of the change itself\n  reasons: [                     \u002F\u002F concise, evidence-based; each cites a file\u002Fbehavior\n    \"New public endpoint POST \u002Fexport added in src\u002Froutes\u002Fexport.ts — user-facing path with no existing gate\",\n    \"No LaunchDarkly usage found near the new route (grepped src\u002Froutes) — this would ship unguarded\"\n  ]\n})\n",[1102],{"type":46,"tag":99,"props":1103,"children":1105},{"__ignoreMap":1104},"",[1106],{"type":52,"value":1100},{"type":46,"tag":55,"props":1108,"children":1109},{},[1110],{"type":52,"value":1111},"Rules for the verdict:",{"type":46,"tag":148,"props":1113,"children":1114},{},[1115,1125,1141,1299,1404,1476],{"type":46,"tag":78,"props":1116,"children":1117},{},[1118,1123],{"type":46,"tag":61,"props":1119,"children":1120},{},[1121],{"type":52,"value":1122},"Call the tool exactly once, as the final step.",{"type":52,"value":1124}," Do not call it before you've explored.",{"type":46,"tag":78,"props":1126,"children":1127},{},[1128,1139],{"type":46,"tag":61,"props":1129,"children":1130},{},[1131,1137],{"type":46,"tag":99,"props":1132,"children":1134},{"className":1133},[],[1135],{"type":52,"value":1136},"reasons",{"type":52,"value":1138}," must be specific and evidence-based.",{"type":52,"value":1140}," Reference the files, symbols, or behaviors you actually observed. Avoid generic statements like \"this is risky.\"",{"type":46,"tag":78,"props":1142,"children":1143},{},[1144,1172,1174,1179,1181,1187,1189,1194,1196,1253,1257,1263,1265,1270,1272,1277,1279,1284,1286,1291,1293,1298],{"type":46,"tag":61,"props":1145,"children":1146},{},[1147,1149,1155,1157,1163,1165,1171],{"type":52,"value":1148},"Set ",{"type":46,"tag":99,"props":1150,"children":1152},{"className":1151},[],[1153],{"type":52,"value":1154},"verdict",{"type":52,"value":1156}," to the specific outcome — keep ",{"type":46,"tag":99,"props":1158,"children":1160},{"className":1159},[],[1161],{"type":52,"value":1162},"already-flagged",{"type":52,"value":1164}," distinct from ",{"type":46,"tag":99,"props":1166,"children":1168},{"className":1167},[],[1169],{"type":52,"value":1170},"not-suited",{"type":52,"value":279},{"type":52,"value":1173}," ",{"type":46,"tag":99,"props":1175,"children":1177},{"className":1176},[],[1178],{"type":52,"value":261},{"type":52,"value":1180}," always pairs with ",{"type":46,"tag":99,"props":1182,"children":1184},{"className":1183},[],[1185],{"type":52,"value":1186},"verdict: \"suggested\"",{"type":52,"value":1188},". ",{"type":46,"tag":99,"props":1190,"children":1192},{"className":1191},[],[1193],{"type":52,"value":567},{"type":52,"value":1195}," splits into two outcomes that must not be collapsed into one \"no flag\" bucket:",{"type":46,"tag":148,"props":1197,"children":1198},{},[1199,1236],{"type":46,"tag":78,"props":1200,"children":1201},{},[1202,1207,1209,1214,1216,1221,1223,1228,1230,1235],{"type":46,"tag":99,"props":1203,"children":1205},{"className":1204},[],[1206],{"type":52,"value":1162},{"type":52,"value":1208}," — the change is ",{"type":46,"tag":291,"props":1210,"children":1211},{},[1212],{"type":52,"value":1213},"already protected",{"type":52,"value":1215},": it ships behind a flag check in the diff, or it lives inside an off \u002F mid-rollout ancestor gate. There ",{"type":46,"tag":61,"props":1217,"children":1218},{},[1219],{"type":52,"value":1220},"is",{"type":52,"value":1222}," a flag; it just isn't a ",{"type":46,"tag":291,"props":1224,"children":1225},{},[1226],{"type":52,"value":1227},"new",{"type":52,"value":1229}," one. Name the flag key (and, for an ancestor, its rollout state) in ",{"type":46,"tag":99,"props":1231,"children":1233},{"className":1232},[],[1234],{"type":52,"value":1136},{"type":52,"value":279},{"type":46,"tag":78,"props":1237,"children":1238},{},[1239,1244,1246,1251],{"type":46,"tag":99,"props":1240,"children":1242},{"className":1241},[],[1243],{"type":52,"value":1170},{"type":52,"value":1245}," — there is ",{"type":46,"tag":291,"props":1247,"children":1248},{},[1249],{"type":52,"value":1250},"genuinely nothing to flag",{"type":52,"value":1252},": a pure refactor, docs\u002Fcomments, tests, dependency bump, or build\u002FCI\u002Ftooling change with no user-observable behavior change.",{"type":46,"tag":1254,"props":1255,"children":1256},"br",{},[],{"type":46,"tag":99,"props":1258,"children":1260},{"className":1259},[],[1261],{"type":52,"value":1262},"recommend",{"type":52,"value":1264}," stays the boolean a CI check keys on; ",{"type":46,"tag":99,"props":1266,"children":1268},{"className":1267},[],[1269],{"type":52,"value":1154},{"type":52,"value":1271}," is the finer signal a dashboard uses to track flag coverage. Collapsing ",{"type":46,"tag":99,"props":1273,"children":1275},{"className":1274},[],[1276],{"type":52,"value":1162},{"type":52,"value":1278}," into ",{"type":46,"tag":99,"props":1280,"children":1282},{"className":1281},[],[1283],{"type":52,"value":1170},{"type":52,"value":1285}," hides real coverage and inflates the apparent \"nothing to flag\" rate — a change protected by an ancestor gate is ",{"type":46,"tag":291,"props":1287,"children":1288},{},[1289],{"type":52,"value":1290},"covered",{"type":52,"value":1292},", not ",{"type":46,"tag":291,"props":1294,"children":1295},{},[1296],{"type":52,"value":1297},"unneeded",{"type":52,"value":279},{"type":46,"tag":78,"props":1300,"children":1301},{},[1302,1321,1323,1328,1330,1335,1337,1342,1344,1376,1378,1383,1385],{"type":46,"tag":61,"props":1303,"children":1304},{},[1305,1307,1313,1315,1320],{"type":52,"value":1306},"Calibrate ",{"type":46,"tag":99,"props":1308,"children":1310},{"className":1309},[],[1311],{"type":52,"value":1312},"confidence",{"type":52,"value":1314}," — do not default to ",{"type":46,"tag":99,"props":1316,"children":1318},{"className":1317},[],[1319],{"type":52,"value":997},{"type":52,"value":279},{"type":52,"value":1322}," Reserve ",{"type":46,"tag":99,"props":1324,"children":1326},{"className":1325},[],[1327],{"type":52,"value":997},{"type":52,"value":1329}," for genuinely clear-cut changes you fully understand (a docs-only diff, an obvious pure refactor, a plainly new user-facing endpoint). Use ",{"type":46,"tag":99,"props":1331,"children":1333},{"className":1332},[],[1334],{"type":52,"value":277},{"type":52,"value":1336}," when the verdict is sound but you couldn't verify every call site, and ",{"type":46,"tag":99,"props":1338,"children":1340},{"className":1339},[],[1341],{"type":52,"value":269},{"type":52,"value":1343}," when the change is ambiguous, borderline, or touches money\u002Fsecurity\u002Fdata on a live path where reasonable reviewers could disagree. ",{"type":46,"tag":61,"props":1345,"children":1346},{},[1347,1349,1354,1356,1361,1362,1367,1369,1374],{"type":52,"value":1348},"If you weighed both directions in Step 3 — i.e. the change is in the Ambiguous table — ",{"type":46,"tag":99,"props":1350,"children":1352},{"className":1351},[],[1353],{"type":52,"value":1312},{"type":52,"value":1355}," MUST be ",{"type":46,"tag":99,"props":1357,"children":1359},{"className":1358},[],[1360],{"type":52,"value":269},{"type":52,"value":271},{"type":46,"tag":99,"props":1363,"children":1365},{"className":1364},[],[1366],{"type":52,"value":277},{"type":52,"value":1368},", never ",{"type":46,"tag":99,"props":1370,"children":1372},{"className":1371},[],[1373],{"type":52,"value":997},{"type":52,"value":1375},", even when you land firmly on a verdict.",{"type":52,"value":1377}," Confidence is about how clear-cut the ",{"type":46,"tag":291,"props":1379,"children":1380},{},[1381],{"type":52,"value":1382},"call",{"type":52,"value":1384}," is, not how strongly you hold your conclusion. ",{"type":46,"tag":61,"props":1386,"children":1387},{},[1388,1390,1395,1397,1402],{"type":52,"value":1389},"Any reason you could not verify against the actual code caps ",{"type":46,"tag":99,"props":1391,"children":1393},{"className":1392},[],[1394],{"type":52,"value":1312},{"type":52,"value":1396}," at ",{"type":46,"tag":99,"props":1398,"children":1400},{"className":1399},[],[1401],{"type":52,"value":277},{"type":52,"value":1403},", and you must name it as unverified.",{"type":46,"tag":78,"props":1405,"children":1406},{},[1407,1425,1427,1432,1434,1439,1441,1446,1448,1453,1455,1460,1462,1467,1469,1474],{"type":46,"tag":61,"props":1408,"children":1409},{},[1410,1411,1417,1419,1424],{"type":52,"value":1148},{"type":46,"tag":99,"props":1412,"children":1414},{"className":1413},[],[1415],{"type":52,"value":1416},"risk",{"type":52,"value":1418}," (optional but recommended) to the change's blast radius — separate from ",{"type":46,"tag":99,"props":1420,"children":1422},{"className":1421},[],[1423],{"type":52,"value":1312},{"type":52,"value":279},{"type":52,"value":1426}," Confidence is how clear-cut the call is; risk is how much damage the change could do. They're orthogonal: a plainly-new-endpoint is a clear call (",{"type":46,"tag":99,"props":1428,"children":1430},{"className":1429},[],[1431],{"type":52,"value":997},{"type":52,"value":1433}," confidence) that might be low blast radius, while an auth-fallthrough tweak can be both ",{"type":46,"tag":99,"props":1435,"children":1437},{"className":1436},[],[1438],{"type":52,"value":997},{"type":52,"value":1440}," confidence and ",{"type":46,"tag":99,"props":1442,"children":1444},{"className":1443},[],[1445],{"type":52,"value":997},{"type":52,"value":1447}," risk. Anchor it: ",{"type":46,"tag":99,"props":1449,"children":1451},{"className":1450},[],[1452],{"type":52,"value":269},{"type":52,"value":1454}," = small, additive, isolated change; ",{"type":46,"tag":99,"props":1456,"children":1458},{"className":1457},[],[1459],{"type":52,"value":277},{"type":52,"value":1461}," = modified business logic \u002F moderate blast radius; ",{"type":46,"tag":99,"props":1463,"children":1465},{"className":1464},[],[1466],{"type":52,"value":997},{"type":52,"value":1468}," = cross-cutting, API-contract, data-migration, or auth\u002Fpayments\u002Fdata-integrity change. A downstream check can use ",{"type":46,"tag":99,"props":1470,"children":1472},{"className":1471},[],[1473],{"type":52,"value":1416},{"type":52,"value":1475}," to prioritize.",{"type":46,"tag":78,"props":1477,"children":1478},{},[1479,1484,1486,1491,1493,1498,1500,1505,1507,1514],{"type":46,"tag":61,"props":1480,"children":1481},{},[1482],{"type":52,"value":1483},"Then summarize in prose",{"type":52,"value":1485}," for the human: restate the verdict, the key reasons, and — if you recommended a flag — a one-line suggestion of what kind (e.g. \"a boolean release flag defaulting to the old behavior\"). Note whether the change is a ",{"type":46,"tag":61,"props":1487,"children":1488},{},[1489],{"type":52,"value":1490},"net-new path",{"type":52,"value":1492}," (the flag-off control renders nothing, so a guarded rollout must lean on existing global\u002Fservice metrics — feature-specific before\u002Fafter comparisons are one-armed) or an ",{"type":46,"tag":61,"props":1494,"children":1495},{},[1496],{"type":52,"value":1497},"incremental change to a live path",{"type":52,"value":1499}," (both variations exercise comparable code, so feature-specific metrics compare cleanly); this tells the release step what its rollout can actually measure. Point them at the flag create skill to actually create it. If the flag you're suggesting will ",{"type":46,"tag":61,"props":1501,"children":1502},{},[1503],{"type":52,"value":1504},"target",{"type":52,"value":1506}," (a rule, individual target, or percentage rollout) rather than being a plain on\u002Foff switch, also point them at ",{"type":46,"tag":1508,"props":1509,"children":1511},"a",{"href":1510},"..\u002Flaunchdarkly-flag-targeting\u002Freferences\u002Fcontext-availability.md",[1512],{"type":52,"value":1513},"Context Availability",{"type":52,"value":1515}," so the targeting names a context kind\u002Fattribute that actually exists where the flag is read.",{"type":46,"tag":55,"props":1517,"children":1518},{},[1519,1521,1526,1528,1534,1536,1541],{"type":52,"value":1520},"If the ",{"type":46,"tag":99,"props":1522,"children":1524},{"className":1523},[],[1525],{"type":52,"value":117},{"type":52,"value":1527}," tool is not available in your environment, emit the exact same object as a fenced ",{"type":46,"tag":99,"props":1529,"children":1531},{"className":1530},[],[1532],{"type":52,"value":1533},"```json",{"type":52,"value":1535}," block labeled ",{"type":46,"tag":99,"props":1537,"children":1539},{"className":1538},[],[1540],{"type":52,"value":117},{"type":52,"value":1542}," so it can still be parsed, then give the prose summary.",{"type":46,"tag":121,"props":1544,"children":1546},{"id":1545},"edge-cases",[1547],{"type":52,"value":1548},"Edge Cases",{"type":46,"tag":641,"props":1550,"children":1551},{},[1552,1568],{"type":46,"tag":645,"props":1553,"children":1554},{},[1555],{"type":46,"tag":649,"props":1556,"children":1557},{},[1558,1563],{"type":46,"tag":653,"props":1559,"children":1560},{},[1561],{"type":52,"value":1562},"Situation",{"type":46,"tag":653,"props":1564,"children":1565},{},[1566],{"type":52,"value":1567},"Action",{"type":46,"tag":664,"props":1569,"children":1570},{},[1571,1603,1624,1656,1676],{"type":46,"tag":649,"props":1572,"children":1573},{},[1574,1579],{"type":46,"tag":671,"props":1575,"children":1576},{},[1577],{"type":52,"value":1578},"Diff is empty or only whitespace",{"type":46,"tag":671,"props":1580,"children":1581},{},[1582,1587,1588,1594,1595,1601],{"type":46,"tag":99,"props":1583,"children":1585},{"className":1584},[],[1586],{"type":52,"value":567},{"type":52,"value":168},{"type":46,"tag":99,"props":1589,"children":1591},{"className":1590},[],[1592],{"type":52,"value":1593},"verdict: not-suited",{"type":52,"value":168},{"type":46,"tag":99,"props":1596,"children":1598},{"className":1597},[],[1599],{"type":52,"value":1600},"confidence: high",{"type":52,"value":1602},", reason noting no behavioral change",{"type":46,"tag":649,"props":1604,"children":1605},{},[1606,1611],{"type":46,"tag":671,"props":1607,"children":1608},{},[1609],{"type":52,"value":1610},"Diff mixes a refactor with a real behavior change",{"type":46,"tag":671,"props":1612,"children":1613},{},[1614,1616,1622],{"type":52,"value":1615},"Judge on the behavior change; recommend a flag if that part warrants it (",{"type":46,"tag":99,"props":1617,"children":1619},{"className":1618},[],[1620],{"type":52,"value":1621},"verdict: suggested",{"type":52,"value":1623},"), and say which part drove the verdict",{"type":46,"tag":649,"props":1625,"children":1626},{},[1627,1632],{"type":46,"tag":671,"props":1628,"children":1629},{},[1630],{"type":52,"value":1631},"Change is already behind a flag — in the diff, or an ancestor gate that's off\u002Fmid-rollout",{"type":46,"tag":671,"props":1633,"children":1634},{},[1635,1640,1641,1647,1649,1654],{"type":46,"tag":99,"props":1636,"children":1638},{"className":1637},[],[1639],{"type":52,"value":567},{"type":52,"value":168},{"type":46,"tag":99,"props":1642,"children":1644},{"className":1643},[],[1645],{"type":52,"value":1646},"verdict: already-flagged",{"type":52,"value":1648},"; name the flag key and, for an ancestor, its rollout state. If the ancestor is fully launched or a permanent config gate, it isn't protecting this change — judge normally (likely ",{"type":46,"tag":99,"props":1650,"children":1652},{"className":1651},[],[1653],{"type":52,"value":1621},{"type":52,"value":1655},").",{"type":46,"tag":649,"props":1657,"children":1658},{},[1659,1664],{"type":46,"tag":671,"props":1660,"children":1661},{},[1662],{"type":52,"value":1663},"You can't read the surrounding code (no repo access, ad hoc snippet)",{"type":46,"tag":671,"props":1665,"children":1666},{},[1667,1669,1674],{"type":52,"value":1668},"Decide from the diff alone; lower ",{"type":46,"tag":99,"props":1670,"children":1672},{"className":1671},[],[1673],{"type":52,"value":1312},{"type":52,"value":1675}," and say exploration was unavailable",{"type":46,"tag":649,"props":1677,"children":1678},{},[1679,1684],{"type":46,"tag":671,"props":1680,"children":1681},{},[1682],{"type":52,"value":1683},"The change is a hotfix \u002F revert",{"type":46,"tag":671,"props":1685,"children":1686},{},[1687,1689,1694],{"type":52,"value":1688},"Usually ",{"type":46,"tag":99,"props":1690,"children":1692},{"className":1691},[],[1693],{"type":52,"value":567},{"type":52,"value":1695}," unless it re-introduces a risky path; explain",{"type":46,"tag":121,"props":1697,"children":1699},{"id":1698},"what-not-to-do",[1700],{"type":52,"value":1701},"What NOT to Do",{"type":46,"tag":148,"props":1703,"children":1704},{},[1705,1715,1725,1735,1753,1770,1804],{"type":46,"tag":78,"props":1706,"children":1707},{},[1708,1713],{"type":46,"tag":61,"props":1709,"children":1710},{},[1711],{"type":52,"value":1712},"Don't create, toggle, or modify any flag.",{"type":52,"value":1714}," You are advisory. See the Scope Boundary.",{"type":46,"tag":78,"props":1716,"children":1717},{},[1718,1723],{"type":46,"tag":61,"props":1719,"children":1720},{},[1721],{"type":52,"value":1722},"Don't gate the merge or speak as a required check",{"type":52,"value":1724}," — frame the output as a recommendation.",{"type":46,"tag":78,"props":1726,"children":1727},{},[1728,1733],{"type":46,"tag":61,"props":1729,"children":1730},{},[1731],{"type":52,"value":1732},"Don't decide from the diff alone when you could read the code.",{"type":52,"value":1734}," Line-level diffs hide blast radius.",{"type":46,"tag":78,"props":1736,"children":1737},{},[1738,1743,1745,1751],{"type":46,"tag":61,"props":1739,"children":1740},{},[1741],{"type":52,"value":1742},"Don't be vague.",{"type":52,"value":1744}," \"Might be risky\" is not a reason; \"changes the auth fallthrough in ",{"type":46,"tag":99,"props":1746,"children":1748},{"className":1747},[],[1749],{"type":52,"value":1750},"middleware\u002Fauth.ts:42",{"type":52,"value":1752}," which every route depends on\" is.",{"type":46,"tag":78,"props":1754,"children":1755},{},[1756,1768],{"type":46,"tag":61,"props":1757,"children":1758},{},[1759,1761,1766],{"type":52,"value":1760},"Don't skip the ",{"type":46,"tag":99,"props":1762,"children":1764},{"className":1763},[],[1765],{"type":52,"value":117},{"type":52,"value":1767}," call.",{"type":52,"value":1769}," Prose without the structured verdict is not a usable result.",{"type":46,"tag":78,"props":1771,"children":1772},{},[1773,1790,1792,1796,1797,1802],{"type":46,"tag":61,"props":1774,"children":1775},{},[1776,1778,1783,1784,1789],{"type":52,"value":1777},"Don't collapse ",{"type":46,"tag":99,"props":1779,"children":1781},{"className":1780},[],[1782],{"type":52,"value":1162},{"type":52,"value":1278},{"type":46,"tag":99,"props":1785,"children":1787},{"className":1786},[],[1788],{"type":52,"value":1170},{"type":52,"value":279},{"type":52,"value":1791}," A change protected by an ancestor gate is ",{"type":46,"tag":291,"props":1793,"children":1794},{},[1795],{"type":52,"value":1290},{"type":52,"value":1292},{"type":46,"tag":291,"props":1798,"children":1799},{},[1800],{"type":52,"value":1801},"nothing to flag",{"type":52,"value":1803}," — record the two distinctly.",{"type":46,"tag":78,"props":1805,"children":1806},{},[1807,1812],{"type":46,"tag":61,"props":1808,"children":1809},{},[1810],{"type":52,"value":1811},"Don't over-flag trivial changes.",{"type":52,"value":1813}," Recommending a flag for a README edit erodes trust in the recommendation.",{"items":1815,"total":1899},[1816,1833,1842,1856,1867,1877,1885],{"slug":1817,"name":1817,"fn":1818,"description":1819,"org":1820,"tags":1821,"stars":23,"repoUrl":24,"updatedAt":1832},"agent-graphs","create and manage agent graphs","Create and manage agent graphs — directed graphs of configs connected by edges with handoff logic. Use when building multi-agent workflows where configs route to each other.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1822,1825,1828,1829],{"name":1823,"slug":1824,"type":15},"Agents","agents",{"name":1826,"slug":1827,"type":15},"Architecture","architecture",{"name":9,"slug":8,"type":15},{"name":1830,"slug":1831,"type":15},"Multi-Agent","multi-agent","2026-07-28T05:33:33.709407",{"slug":1834,"name":1834,"fn":1835,"description":1836,"org":1837,"tags":1838,"stars":23,"repoUrl":24,"updatedAt":1841},"aiconfig-agent-graphs","manage agent graphs","DEPRECATED redirect — this skill was renamed to agent-graphs. Do not use this skill; invoke agent-graphs instead. Kept only so old references to aiconfig-agent-graphs still point users to the new name.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1839,1840],{"name":1823,"slug":1824,"type":15},{"name":1826,"slug":1827,"type":15},"2026-05-22T06:55:56.527064",{"slug":1843,"name":1843,"fn":1844,"description":1845,"org":1846,"tags":1847,"stars":23,"repoUrl":24,"updatedAt":1855},"aiconfig-ai-metrics","manage built-in AI metrics","DEPRECATED redirect — this skill was renamed to built-in-metrics. Do not use this skill; invoke built-in-metrics instead. Kept only so old references to aiconfig-ai-metrics still point users to the new name.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1848,1851,1852],{"name":1849,"slug":1850,"type":15},"Analytics","analytics",{"name":9,"slug":8,"type":15},{"name":1853,"slug":1854,"type":15},"Metrics","metrics","2026-05-22T06:55:53.858749",{"slug":1857,"name":1857,"fn":1858,"description":1859,"org":1860,"tags":1861,"stars":23,"repoUrl":24,"updatedAt":1866},"aiconfig-create","redirect to configs-create skill","DEPRECATED redirect — this skill was renamed to configs-create. Do not use this skill; invoke configs-create instead. Kept only so old references to aiconfig-create still point users to the new name.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1862,1863],{"name":9,"slug":8,"type":15},{"name":1864,"slug":1865,"type":15},"Reference","reference","2026-05-22T06:55:41.790591",{"slug":1868,"name":1868,"fn":1869,"description":1870,"org":1871,"tags":1872,"stars":23,"repoUrl":24,"updatedAt":1876},"aiconfig-custom-metrics","configure custom metrics in LaunchDarkly","DEPRECATED redirect — this skill was renamed to custom-metrics. Do not use this skill; invoke custom-metrics instead. Kept only so old references to aiconfig-custom-metrics still point users to the new name.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1873,1874,1875],{"name":1849,"slug":1850,"type":15},{"name":17,"slug":18,"type":15},{"name":9,"slug":8,"type":15},"2026-05-22T06:55:57.84851",{"slug":1878,"name":1878,"fn":1879,"description":1880,"org":1881,"tags":1882,"stars":23,"repoUrl":24,"updatedAt":1884},"aiconfig-migrate","redirect to migrate skill","DEPRECATED redirect — this skill was renamed to migrate. Do not use this skill; invoke migrate instead. Kept only so old references to aiconfig-migrate still point users to the new name.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1883],{"name":1864,"slug":1865,"type":15},"2026-05-22T06:55:44.464733",{"slug":1886,"name":1886,"fn":1887,"description":1888,"org":1889,"tags":1890,"stars":23,"repoUrl":24,"updatedAt":1898},"aiconfig-online-evals","run online evaluations","DEPRECATED redirect — this skill was renamed to online-evals. Do not use this skill; invoke online-evals instead. Kept only so old references to aiconfig-online-evals still point users to the new name.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1891,1894,1895],{"name":1892,"slug":1893,"type":15},"Evals","evals",{"name":9,"slug":8,"type":15},{"name":1896,"slug":1897,"type":15},"Testing","testing","2026-05-22T06:55:55.179617",49,{"items":1901,"total":1899},[1902,1909,1914,1920,1925,1931,1935,1941,1952,1961,1971,1980],{"slug":1817,"name":1817,"fn":1818,"description":1819,"org":1903,"tags":1904,"stars":23,"repoUrl":24,"updatedAt":1832},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1905,1906,1907,1908],{"name":1823,"slug":1824,"type":15},{"name":1826,"slug":1827,"type":15},{"name":9,"slug":8,"type":15},{"name":1830,"slug":1831,"type":15},{"slug":1834,"name":1834,"fn":1835,"description":1836,"org":1910,"tags":1911,"stars":23,"repoUrl":24,"updatedAt":1841},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1912,1913],{"name":1823,"slug":1824,"type":15},{"name":1826,"slug":1827,"type":15},{"slug":1843,"name":1843,"fn":1844,"description":1845,"org":1915,"tags":1916,"stars":23,"repoUrl":24,"updatedAt":1855},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1917,1918,1919],{"name":1849,"slug":1850,"type":15},{"name":9,"slug":8,"type":15},{"name":1853,"slug":1854,"type":15},{"slug":1857,"name":1857,"fn":1858,"description":1859,"org":1921,"tags":1922,"stars":23,"repoUrl":24,"updatedAt":1866},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1923,1924],{"name":9,"slug":8,"type":15},{"name":1864,"slug":1865,"type":15},{"slug":1868,"name":1868,"fn":1869,"description":1870,"org":1926,"tags":1927,"stars":23,"repoUrl":24,"updatedAt":1876},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1928,1929,1930],{"name":1849,"slug":1850,"type":15},{"name":17,"slug":18,"type":15},{"name":9,"slug":8,"type":15},{"slug":1878,"name":1878,"fn":1879,"description":1880,"org":1932,"tags":1933,"stars":23,"repoUrl":24,"updatedAt":1884},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1934],{"name":1864,"slug":1865,"type":15},{"slug":1886,"name":1886,"fn":1887,"description":1888,"org":1936,"tags":1937,"stars":23,"repoUrl":24,"updatedAt":1898},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1938,1939,1940],{"name":1892,"slug":1893,"type":15},{"name":9,"slug":8,"type":15},{"name":1896,"slug":1897,"type":15},{"slug":1942,"name":1942,"fn":1943,"description":1944,"org":1945,"tags":1946,"stars":23,"repoUrl":24,"updatedAt":1951},"aiconfig-projects","manage AI configuration projects","DEPRECATED redirect — this skill was renamed to projects. Do not use this skill; invoke projects instead. Kept only so old references to aiconfig-projects still point users to the new name.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1947,1950],{"name":1948,"slug":1949,"type":15},"Configuration","configuration",{"name":9,"slug":8,"type":15},"2026-05-22T06:55:48.522229",{"slug":1953,"name":1953,"fn":1954,"description":1955,"org":1956,"tags":1957,"stars":23,"repoUrl":24,"updatedAt":1960},"aiconfig-snippets","manage AI configuration snippets","DEPRECATED redirect — this skill was renamed to snippets. Do not use this skill; invoke snippets instead. Kept only so old references to aiconfig-snippets still point users to the new name.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1958,1959],{"name":1948,"slug":1949,"type":15},{"name":9,"slug":8,"type":15},"2026-05-22T06:55:47.16557",{"slug":1962,"name":1962,"fn":1963,"description":1964,"org":1965,"tags":1966,"stars":23,"repoUrl":24,"updatedAt":1970},"aiconfig-targeting","configure LaunchDarkly targeting rules","DEPRECATED redirect — this skill was renamed to configs-targeting. Do not use this skill; invoke configs-targeting instead. Kept only so old references to aiconfig-targeting still point users to the new name.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1967,1968,1969],{"name":1948,"slug":1949,"type":15},{"name":17,"slug":18,"type":15},{"name":9,"slug":8,"type":15},"2026-05-22T06:55:49.845445",{"slug":1972,"name":1972,"fn":1973,"description":1974,"org":1975,"tags":1976,"stars":23,"repoUrl":24,"updatedAt":1979},"aiconfig-tools","redirect to tools skill","DEPRECATED redirect — this skill was renamed to tools. Do not use this skill; invoke tools instead. Kept only so old references to aiconfig-tools still point users to the new name.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1977,1978],{"name":9,"slug":8,"type":15},{"name":1864,"slug":1865,"type":15},"2026-05-22T06:55:39.13373",{"slug":1981,"name":1981,"fn":1982,"description":1983,"org":1984,"tags":1985,"stars":23,"repoUrl":24,"updatedAt":1988},"aiconfig-update","redirect to configs-update skill","DEPRECATED redirect — this skill was renamed to configs-update. Do not use this skill; invoke configs-update instead. Kept only so old references to aiconfig-update still point users to the new name.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1986,1987],{"name":9,"slug":8,"type":15},{"name":1864,"slug":1865,"type":15},"2026-05-22T06:55:40.464884"]