Skip to content
Skills Library
Programming · Building & coding

feature

/feature

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".

Repository
godmode ↗
Licence
MIT
Last repository change
28.08.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
1
URLs in SKILL.md
0
Deprecation

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

Licence

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

What to check before installing
  • SKILL.md zawiera komentarze HTML (1). Nie widać ich w podglądzie Markdown, a model je czyta.

What it does and when to use it

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".

Triggers from the description

feature flaggradual rolloutkill switchA/B test
Original author description

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".

How it works

  1. Activate When
  2. Workflow
  3. Key Behaviors
  4. HARD RULES
  5. Auto-Detection
  6. Output Format
  7. TSV Logging
  8. Keep/Discard Discipline
  9. Stop Conditions
  10. Error Recovery
Original SKILL.md headings · 213 lines, 878 words
SKILL.md preview
---
name: feature
description: |
  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".
---

# Feature — Feature Flags & Progressive Delivery

## Activate When
- User invokes `/godmode:feature`
- User says "feature flag", "gradual rollout"
- User says "kill switch", "A/B test"
- Deploying needs safer rollout or deploy/release decoupling

## Workflow

### Step 1: Flag Strategy Assessment

```bash
# Detect existing flag infrastructure
grep -r "launchdarkly\|unleash\|flagsmith\|split\|statsig" \
  package.json pyproject.toml 2>/dev/null

# Find existing flag usage
grep -rn "featureFlag\|isEnabled\|isFeatureEnabled" \
  src/ --include="*.ts" --include="*.py" 2>/dev/null | wc -l

# Check for stale flags (not evaluated in 30+ days)
grep -rn "featureFlag\|isEnabled" src/ \
  --include="*.ts" 2>/dev/null | head -20
```

```
FLAG STRATEGY:
  Current: None | Homegrown | LaunchDarkly | Unleash
  Flag needs: Release | Experiment | Ops | Permission
  Environments: Dev | Staging | Prod | Mobile

IF < 5 flags: Homegrown or Flagsmith OSS
IF 5-50 flags: Unleash or Flagsmith
IF 50+ flags with experiments: LaunchDarkly
IF strict data residency: self-hosted
```

### Step 2: Flag Types

```
| Type       | Lifecycle   | Default | Duration  |
|------------|-------------|---------|-----------|
| Release    | Short-lived | OFF     | < 2 weeks |
| Experiment | Short-lived | CONTROL | < 4 weeks |
| Ops/Kill   | Permanent   | ON      | Forever   |
| Permission | Permanent   | OFF     | Forever   |

RELEASE RAMP:
  CREATE → INTERNAL → CANARY 1% → 5% → 25%
    → 50% → 100% → CLEANUP (within 2 weeks)

EXPERIMENT RAMP:
  CREATE → CONFIGURE → RUN → SIGNIFICANCE
    → PICK WINNER → CLEANUP (within 1 week)
```

### Step 3: Targeting & Gradual Rollout

```
RULE PRIORITY (top to bottom):
  1. Individual overrides
  2. Employee targeting
  3. Beta segment
  4. Percentage rollout
  5. Default OFF

ROLLOUT STAGES:
  Internal (0.1%) 1d → Canary (1%) 1-2d
    → Early (5%) 2-3d → Expanding (25%) 3-5d
    → Majority (50%) 3-5d → Full (100%)

GATE CRITERIA (advance only if all pass):
  Error rate < baseline + 0.1%
  P95 latency < baseline + 10%
  Conversion > baseline - 2%
  Support tickets < baseline + 5%

STICKY BUCKETING:
  hash(flagKey:userId) % 10000 / 100
  Same user always sees same variant
  Increasing % adds users, never flips existing
```

### Step 4: Kill Switches

```
REQUIREMENTS:
  Effect in < 30 seconds, no deploy needed
  Dashboard/CLI accessible, audit trail
  Hierarchy: Global → Service → Feature → Region

AUTO-TRIGGERS:
  IF error rate > 5% for 2min: disable flag
  IF P99 > 3x baseline for 5min: disable flag

FALLBACK:
  Locally cached values (5min TTL)
  Then hardcoded defaults
  Never crash because flag service is down
```

### Step 5: Lifecycle Management

```
NAMING CONVENTION:
  enable_<feature> (release)
  exp_<name> (experiment)
  disable_<feature> (ops kill switch)

STALE FLAG DETECTION:
  Release at 100% for > 2 weeks: STALE
  Experiment concluded > 1 week: STALE
  Not evaluated in > 30 days: STALE
  > 90 days without cleanup date: STALE

THRESHOLDS:
  Max flags per service: 50 (audit if more)
  Evaluation latency: < 5ms (in-memory cache)
  Cache refresh interval: 30 seconds
  Cleanup deadline: 2 weeks after 100%
```

### Step 6: A/B Testing Integration

```
PROCESS:
  1. Define hypothesis + primary metric
  2. Set guardrail metrics (must not regress)
  3. Calculate sample size for power 0.80
  4. Configure sticky bucketing variants
  5. Wait for significance (p < 0.05)

THRESHOLDS:
  Minimum duration: 7 days (full business cycle)
  Alpha: 0.05, Power: 0.80
  Never peek before minimum sample reached
  Correct for multiple testing if > 2 variants
```

### Step 7: Validation
Check: types categorized, naming enforced,
  owner assigned, cleanup dates set, kill switches
  defined, sticky bucketing, fallback behavior,
  audit trail, evaluation < 5ms.

Commit: `"feature: <flag_name> — <type> at <pct>%"`

## Key Behaviors
Never ask to continue. Loop autonomously until done.

1. **Flags are temporary by default.** Cleanup required.
2. **Decouple deploy from release.** Ship dark.
3. **Kill switches are not optional.**
4. **Clean up flags.** Max 2 weeks at 100%.
5. **Sticky bucketing is mandatory.**
6. **Test both paths.** On, off, and transition.
7. **Default to off, fail to off.**

## HARD RULES
1. Never leave release flags at 100% for > 2 weeks.
2. Never nest flag checks. Keep flags independent.
3. Never use flags as permanent config.
4. Always test both flag-on AND flag-off paths.
5. Never evaluate flags in hot loops. Once per request.
6. Never expose server-side targeting rules to clients.
7. Never call experiment winner without sample size.
8. Always maintain an audit trail for flag changes.

## Auto-Detection
```bash
grep -r "launchdarkly\|unleash\|flagsmith" package.json
grep -rl "featureFlag\|isEnabled" src/ --include="*.ts"
```

## Output Format
Print: `Feature: {flag} at {pct}% rollout.
  Error={err}%, latency_p99={lat}ms.
  Kill switch: {tested|untested}. Status: {status}.`

## TSV Logging
```
step	flag_name	flag_type	platform	status	details
```

## Keep/Discard Discipline
```
KEEP if: metrics within guardrails AND no error spike
  AND kill switch tested
DISCARD if: error > baseline+0.1% OR latency > +10%
  OR conversion drops > 2%
On discard: roll back to previous percentage.
```

## Stop Conditions
```
STOP when ALL of:
  - Flag at 100% with stable metrics for 7 days
  - Kill switch tested and verified
  - Cleanup scheduled (within 2 weeks)
```

<!-- tier-3 -->

## Error Recovery
- SDK init fails: check API key, implement fallbacks.
- Flag not evaluating: check context (user.id passed?).
- Rollout errors: set to 0%, check logs, resume at 1%.
- Stale flags: run audit, remove code, delete branches.
- Conflicting flags: map deps, encode as prerequisites.

Versions

RepositoryScoreLicence
This page · arbazkhan971/godmode100MIT
A7-studio/jobmigo100MIT
crbnos/carbon100AGPL-3.0
arxdsilva/ai-loops100MIT
jisuzzzz/haechi100MIT
pawangai/pawang-agents100MIT
andrewBezerra/concordia100MIT
cryndoc/polisade-orchestrator100Apache-2.0
ChandraChaan/flutter-agent-skills100MIT

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

Downloads in the last 30 days: 0 · ranking

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

Similar skills

  • 100feature-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…
  • 90backend-feature-flags
    Use this skill when implementing feature flags, canary releases, A/B testing, or kill switches. This skill enforces: flag ownership with removal date, cached evaluation, kill switches for critical features, safe defaults (off). Applies to LaunchDarkly, Unleash, Flagsmith, or…
  • 100feature-flags
    Implement feature flags for progressive feature rollout using LaunchDarkly, Unleash, or custom solutions. Control feature visibility, perform A/B testing, and enable trunk-based development. Use when implementing gradual rollouts, feature toggles, or experimentation platforms.
  • 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,"…
  • 100openfeature-sdk-testing
    Use whenever code that reads feature flags through OpenFeature, Unleash, Flagsmith or GrowthBook needs tests: InMemoryProvider for hermetic tests, evaluation details, hooks and targeting context in TypeScript, Java and Python, plus a flag test-matrix workflow. LaunchDarkly has launchdarkly-testing.
  • 100feature-flag
    Feature flag implementation, management, and cleanup. Handles flag creation, gradual rollout strategies, A/B testing wiring, stale flag detection, and safe flag removal. Supports LaunchDarkly, Unleash, GrowthBook, Statsig, custom env-var flags, and database-backed toggles. Use…

Feedback and reports

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