Index of every page on this site: llms.txt
All skills
launchdarkly avatar

/flag-and-release-change

@f0ee110 official
Run it yourself

Drive a pull request's change end to end: decide it's flag-worthy, create the guarding flag, wire the new code path behind it on the PR branch, and start a flag release so the change ships safely when the PR merges. A portable orchestrator that composes should-flag-change, launchdarkly-flag-create, and flag-release. Keywords: flag a PR, wrap change in a flag, dark launch, kill switch, auto-release, flag release, end-to-end flag workflow.

Use this Skill: https://skilld.dev/gh/launchdarkly/ai-tooling/flag-and-release-change

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈117 tokens for metadata: the name and description. ≈2.5k when used: this file. ≈1.4k more on demand in 3 files.

Description uses 5.8% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈467 characters, or 5.8%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Flag & Release a PR Change

You're using a skill that takes a pull request whose change should ship behind a feature flag and drives it end to end: decide it needs a flag, create the guarding flag, wire the new behavior behind it on the PR's branch, and start a flag release so the change ships safely once the PR merges.

The deploy is not the release. The merge ships the control path — the flag is created OFF, so deployment always serves the pre-change behavior. The release is the flag operation the flag release performs afterward, governed by the project's flag release plan when it has one, and by the environment release plans. Creating the flag OFF and starting the release are deliberately separate things.

This skill is a portable PR orchestrator. It doesn't own the flag mechanics or the release mechanics — it composes three focused skills and adds the PR workflow (read the diff, work in a clone, push to the branch) plus the plan→implement sequencing:

Step Owned by This skill's role
Decide whether to flag should-flag-change (advisory, read-only) Act on a "yes"; make the call yourself if it wasn't run
Create the flag + wire the code launchdarkly-flag-create Invoke it against the change; don't re-teach flag creation or SDK patterns
Start the release flag-release Hand off once the flag exists and the code is pushed; don't re-teach rollout mechanics

Don't duplicate any composed skill's mechanics here. This skill's only unique content is the PR wrapper (clone, three-dot diff, commit/push to the branch) and the plan→implement flow that stitches the three together.

Automation note. An orchestrating harness (e.g. a PR pipeline) can skip this skill and invoke the three composed skills directly — should-flag-change → launchdarkly-flag-create → flag-release — driving the git and sequencing itself. This skill is the portable, human-in-the-loop path for a developer working a PR by hand.

You work in two phases — plan, then implement — and you check in with the user in between. Never create or modify anything during the plan phase.

Prerequisites

  • The remotely hosted LaunchDarkly MCP server.
  • A git CLI that can read and push to the PR's repository.
  • The composed skills available: launchdarkly-flag-create (flag creation + code wiring) and flag-release (starting the release). should-flag-change is used if the flag decision hasn't been made.

MCP tools are used via the composed skills — create-flag/get-flags through flag-create, get-flag-release-plans/get-environment-release-plans/create-flag-release through flag-release. This skill calls none directly.

Working With the Pull Request

Work from a clone so you can read the change and push the flag wiring back to its branch. Use the git access the user already set up for this repository. Never ask for, print, or store tokens, and do not search environment variables, .env files, or credential files for them.

git clone https://github.com/<owner>/<repo>.git && cd <repo>
git fetch origin pull/<pr_number>/head
git diff origin/HEAD...<head_sha>       # three-dot: change relative to the PR's base

The three-dot diff (base...head) shows exactly what the PR introduces. Read the changed files you need to understand the change and its risk. Stay in this clone through both phases — in implement you edit, commit, and push here. Full PR mechanics (clone, three-dot diff, commit/push to the branch): references/pr-wiring.md.

Plan Phase

Create nothing in this phase.

  1. Confirm it should be flagged. If should-flag-change already ran, act on its verdict. Otherwise apply the same judgment: favor a flag for user-facing or risky changes; skip config-only, dependency-bump, infra, test-only, or docs changes. If a flag clearly isn't warranted, say so and stop.
  2. Understand the change and conventions. Read the three-dot diff and changed files — what does it do, what's the blast radius? Then follow flag-create's Step 1 to learn how this codebase already uses flags (SDK, wrapper, key constants, naming). Don't reinvent that exploration here.
  3. Design the flag. Usually a single boolean kill-switch around the new path (flag-create's flag-types covers the choice). Don't propose more flags than the change needs. If Step 1 (or should-flag-change) surfaced a dependency on a parent flag/feature that isn't live yet, note it — the release step can couple them with a prerequisite.
  4. Plan the release. Follow flag-release's plan phase: find the project, choose how to start the release (the flag release plan, or each environment's release plan), preview each environment release plan (the plans don't depend on the flag, so this works before the flag exists), capture the human's release intent (release on merge / hold / notBefore / segment / prerequisite), and check that the release honors it. Don't re-derive the release model here: that's flag-release's job.
  5. Present the combined plan and stop. Summarize: the flag (key, name, boolean, tags) and why it gates this change; where in the code the guard goes; how the release starts (the flag release plan, or each environment's release plan), the per-environment release plan + captured intent (and anything to be held or not part of the release). If the flag release plan does not fit the intent, say that the release starts from each environment's release plan instead, and why. Then wait. Revise on feedback; proceed only on clear approval. Ask a focused question if you're genuinely missing something (project key, environments) rather than guessing.

Implement Phase

Only after approval:

  1. Create the flag and wire the code using launchdarkly-flag-create (its Steps 3–4): flag created OFF with the agreed key/tags, guarding evaluation added with a safe default matching the codebase's pattern. Fail closed on creation errors: only an "already exists" result is success-via-reuse. Any other create-flag failure (auth, permissions, not-found, server error) is a hard stop — do not wire the code, start the release, or report success. A false "flag created" yields a green PR referencing a flag that doesn't exist, worse than an honest failure. Surface the error and stop.
  2. Add paired flag-on / flag-off tests. If the repo has a test suite, add a test for each state of the wrapped path — flag ON serves the new behavior, flag OFF preserves the old — matching the repo's framework and flag-mocking convention. Run them and continue only once green. Scope the tests to the flagged path, not general coverage. If the repo has no tests, skip and say so.
  3. Commit and push to the PR branch. Commit the wiring and push to the PR's existing branch so it lands in the same PR — don't open a new PR or touch the base branch. See references/pr-wiring.md.
  4. Start the release by handing off to flag-release's implement phase: it starts the flag release from the agreed plan, honoring the captured intent (it starts nothing that would release a held environment) and returns a config_id. Don't re-teach the release mechanics here.
  5. Report the whole change: flag key + LaunchDarkly link (created OFF); the file(s)/code path wired; the tests added; the per-environment release plan + config_id; what was held (and why) versus what releases on merge. Report only what you verified.

Edge Cases

Situation Action
Change isn't flag-worthy Explain why (config-only, dep bump, infra, test-only, docs) and stop. Don't create a flag.
Flag already exists Reuse it — "already exists" is success. Wire the existing key; don't duplicate.
Flag creation fails for any other reason (auth, permissions, 5xx) Hard stop. Don't wire code, start a release, or claim success — surface the error.
Codebase has no LaunchDarkly SDK Wiring can't evaluate a flag — SDK install is separate (onboarding/sdk-install).
Guarding needs more than a boolean Prefer a boolean kill-switch. Only go multivariate if the change serves distinct variants; see flag-create's flag-types.
Release-specific cases (hold/notBefore, prerequisites, no fitting flag release plan, an active release, no useful metric) Handled by flag-release — see its edge cases.

What NOT to Do

  • Don't create anything in the plan phase. Plan proposes; implement creates.
  • Don't re-document flag creation, SDK guarding, or rollout mechanics here — those are launchdarkly-flag-create and flag-release. Link to them.
  • Don't turn the flag on yourself. The flag release owns that; creating the flag OFF is the point.
  • Don't over-flag. One kill-switch beats several speculative flags.
  • Don't handle or print credentials. Use the user's existing git access; never read tokens from the machine.

References

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 warningtoday3 checks · Risk SAFE
  • Gen Agent Trust Hub1d

    The skill is a pull request orchestrator for LaunchDarkly feature flags. It follows security best practices by explicitly forbidding credential access and requiring user confirmation before performing actions. The primary security consideration is the inherent risk of indirect prompt injection when processing untrusted code and diffs from pull requests.

  • Sockettoday

    No alerts

  • Snyk1d

    Risk: MEDIUM · 1 issue

Signed by skilld at f0ee110. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated 4 days ago
metadata
{
  "author": "launchdarkly",
  "version": "0.3.0"
}
Other metadata
compatibility
Requires the remotely hosted LaunchDarkly MCP server and a git CLI with access to the PR's repository

README badge

README badge for launchdarkly/ai-tooling/flag-and-release-change