Skip to content
Skills Library
DevOps & cloud · Tool integration

feature-flags

/feature-flags

Feature flag management. LaunchDarkly, Unleash, Flagsmith, and custom implementations. Gradual rollouts, A/B testing, kill switches, and flag lifecycle management. USE WHEN: user mentions "feature flag", "feature toggle", "LaunchDarkly", "Unleash", "Flagsmith", "gradual rollout", "A/B test", "canary release", "kill switch" DO NOT USE FOR: CI/CD deployment strategies - use `github-actions`; environment config - use environment variable patterns

Licence
MIT
Last repository change
21.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
1
Deprecation

No signals detected. Repository changed on 21.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Feature flag management. LaunchDarkly, Unleash, Flagsmith, and custom implementations. Gradual rollouts, A/B testing, kill switches, and flag lifecycle management. USE WHEN: user mentions "feature flag", "feature toggle", "LaunchDarkly", "Unleash", "Flagsmith", "gradual rollout", "A/B test", "canary release", "kill switch" DO NOT USE FOR: CI/CD deployment strategies - use `github-actions`; environment config - use environment variable patterns

Triggers from the description

feature flagfeature toggleLaunchDarklyUnleashFlagsmithgradual rolloutA/B testcanary release
Original author description

Feature flag management. LaunchDarkly, Unleash, Flagsmith, and custom implementations. Gradual rollouts, A/B testing, kill switches, and flag lifecycle management. USE WHEN: user mentions "feature flag", "feature toggle", "LaunchDarkly", "Unleash", "Flagsmith", "gradual rollout", "A/B test", "canary release", "kill switch" DO NOT USE FOR: CI/CD deployment strategies - use `github-actions`; environment config - use environment variable patterns

How it works

  1. LaunchDarkly
  2. Unleash (self-hosted)
  3. Custom Implementation (simple)
  4. Flag Types
  5. Anti-Patterns
  6. Production Checklist
Original SKILL.md headings · 114 lines, 390 words
SKILL.md preview
---
name: feature-flags
description: |
  Feature flag management. LaunchDarkly, Unleash, Flagsmith, and custom
  implementations. Gradual rollouts, A/B testing, kill switches,
  and flag lifecycle management.

  USE WHEN: user mentions "feature flag", "feature toggle", "LaunchDarkly",
  "Unleash", "Flagsmith", "gradual rollout", "A/B test", "canary release",
  "kill switch"

  DO NOT USE FOR: CI/CD deployment strategies - use `github-actions`;
  environment config - use environment variable patterns
allowed-tools: Read, Grep, Glob, Write, Edit
---
# Feature Flags

## LaunchDarkly

```typescript
import * as LaunchDarkly from '@launchdarkly/node-server-sdk';

const client = LaunchDarkly.init(process.env.LD_SDK_KEY!);
await client.waitForInitialization();

// Evaluate flag
const showNewUI = await client.variation('new-dashboard-ui', {
  key: user.id,
  email: user.email,
  custom: { plan: user.plan },
}, false); // default value

if (showNewUI) {
  renderNewDashboard();
} else {
  renderLegacyDashboard();
}
```

### React SDK

```tsx
import { useFlags, withLDProvider } from 'launchdarkly-react-client-sdk';

function Dashboard() {
  const { newDashboardUi, maxUploadSize } = useFlags();

  return newDashboardUi ? <NewDashboard maxUpload={maxUploadSize} /> : <LegacyDashboard />;
}

// Wrap app
export default withLDProvider({
  clientSideID: process.env.NEXT_PUBLIC_LD_CLIENT_ID!,
  context: { kind: 'user', key: user.id, email: user.email },
})(App);
```

## Unleash (self-hosted)

```typescript
import { initialize } from 'unleash-client';

const unleash = initialize({
  url: 'https://unleash.example.com/api',
  appName: 'my-app',
  customHeaders: { Authorization: process.env.UNLEASH_API_KEY! },
});

if (unleash.isEnabled('new-checkout', { userId: user.id })) {
  // New checkout flow
}
```

## Custom Implementation (simple)

```typescript
interface FeatureFlags {
  [key: string]: {
    enabled: boolean;
    rolloutPercentage?: number;
    allowedUsers?: string[];
  };
}

class FlagService {
  constructor(private flags: FeatureFlags) {}

  isEnabled(flag: string, userId?: string): boolean {
    const config = this.flags[flag];
    if (!config?.enabled) return false;
    if (config.allowedUsers?.includes(userId!)) return true;
    if (config.rolloutPercentage != null && userId) {
      const hash = simpleHash(userId + flag) % 100;
      return hash < config.rolloutPercentage;
    }
    return config.enabled;
  }
}
```

## Flag Types

| Type | Purpose | Example |
|------|---------|---------|
| Boolean | On/off toggle | `new-ui-enabled` |
| Percentage rollout | Gradual release | 10% → 50% → 100% |
| User targeting | Specific users | Beta testers, internal |
| Multivariate | A/B/C testing | `checkout-variant: "A"` |
| Kill switch | Emergency disable | `payments-enabled` |

## Anti-Patterns

| Anti-Pattern | Fix |
|--------------|-----|
| Flags that live forever | Set expiration, clean up after full rollout |
| Flag checks deep in code | Check at entry points, pass result down |
| No default values | Always provide sensible defaults |
| Testing only flagged-on path | Test both paths in CI |
| Flags in tight loops | Cache flag evaluation result |

## Production Checklist

- [ ] Default values for all flags (graceful degradation)
- [ ] Flag naming convention (`feature-name-action`)
- [ ] Cleanup process for fully-rolled-out flags
- [ ] Monitoring: flag evaluation metrics
- [ ] Testing both flag states in CI
- [ ] Audit log of flag changes

Versions

RepositoryScoreLicence
This page · claude-dev-suite/claude-dev-suite100MIT
mthines/lorekit100MIT
builderio/agent-native100MIT
facebook/react100MIT
RobinBeraud/claude-qa-skills100MIT
SkillMedev/skills100MIT
andersonlimahw/lemon-ai-hub100MIT
marcus/sidecar100MIT
growthbook/skills100MIT

Database snapshot: 13.11.2026 · package version 235d158baca0 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 1 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100feature
    Feature flag design, gradual rollouts, A/B testing, kill switches. LaunchDarkly, Unleash, Flagsmith. Triggers on: /godmode:feature, "feature flag", "gradual rollout", "kill switch", "A/B test".
  • 100feature-flag-configuration-launchdarkly-and-unleash
    Designs and operates feature flag configuration with LaunchDarkly or Unleash, covering flag lifecycle (create, target, roll out, retire), kill-switch patterns for fast incident mitigation without a redeploy, targeting/segmentation rules, and cleaning up stale flag debt before it…
  • 90frontend-feature-flags
    Use this skill when the user says 'feature flags', 'LaunchDarkly', 'split testing', 'A/B testing', 'gradual rollout', 'canary release', 'feature toggle', 'flag provider', 'targeting rule', or when implementing frontend feature flags. This skill enforces: typed flag definitions,…
  • 100feature-flag-rollout-strategist
    Use when introducing a feature flag system, choosing between release flags / experiment flags / operational flags / kill switches / permission flags, designing percentage rollouts, building kill-switch + circuit-breaker patterns, structuring evaluation contexts (user IDs, plan…
  • 100feature-flag-testing
    When the user wants to test code controlled by feature flags — variation coverage, flag combinations, canary / progressive rollout, A/B test correctness, kill-switch behavior. Use when the user mentions "feature flags," "feature toggles," "LaunchDarkly," "Split.io," "Unleash,"…
  • 100feature-flags-architect
    Feature flag strategy, lifecycle, and operations. Use when designing a flag taxonomy, planning a gradual rollout, building kill switches, auditing flag debt, defining governance, running progressive delivery, or rolling back via flags.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.