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

/projects

@f0ee110 official
Run it yourself

Guide for setting up LaunchDarkly projects in your codebase. Helps you assess your stack, choose the right approach, and integrate project management that makes sense for your architecture.

Use this Skill: https://skilld.dev/gh/launchdarkly/ai-tooling/projects

Nothing lands on disk. Nothing to clean up.

Fork this Skill

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

SKILL.md

≈50 tokens for metadata: the name and description. ≈2.6k when used: this file. ≈24k more on demand in 10 files.

Description uses 2.5% 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 ≈200 characters, or 2.5%.

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.

LaunchDarkly Projects Setup

You're using a skill that will guide you through setting up LaunchDarkly project management in a codebase. Your job is to explore the codebase to understand the stack and patterns, assess what approach makes sense, choose the right implementation path from the references, execute the setup, and verify it works.

Prerequisites

  • The remotely hosted LaunchDarkly MCP server configured in your environment
  • An API access token with projects:write permission, only if you're building code that creates projects (scripts, IaC, admin tools)

Core Principles

  1. Understand First: Explore the codebase to understand the stack and patterns.
  2. Choose the Right Fit: Select an approach that matches your architecture.
  3. Follow Conventions: Respect existing code style and structure.
  4. Verify Integration: Confirm the setup works: the agent performs checks and reports results.

API Access

When you create or inspect a project yourself, use the LaunchDarkly MCP server tools: create-project and get-projects (with projectKey for one project and its environments). They authenticate via OAuth and need no token.

To get the server-side SDK key the app needs, call get-sdk-key with projectKey and environmentKey. get-environment returns only the client-side ID and mobile key. Do not search environment variables, .env files, or agent/MCP config files for credentials.

The reference guides call the REST API because they build code that runs without the agent.

What Are Projects?

Projects are LaunchDarkly's top-level organizational containers that hold:

  • All your configs
  • Feature flags and segments
  • Multiple environments (Production and Test created by default)

Think of projects as separate applications, services, or teams that need their own isolated set of configurations.

Project Setup Workflow

Step 1: Explore the Codebase

Before implementing anything, understand the existing architecture:

  1. Identify the tech stack:

    • What language(s)? (Python, Node.js, Go, Java, etc.)
    • What framework(s)? (FastAPI, Express, Spring Boot, etc.)
    • Is there an existing LaunchDarkly integration?
  2. Check environment management:

    • How are environment variables stored? (.env files, secrets manager, config files)
    • Where is configuration loaded? (startup scripts, config modules)
    • Are there existing LaunchDarkly SDK keys?
  3. Look for patterns:

    • Are there existing API clients or service modules?
    • How is external API integration typically done?
    • Is there a CLI, scripts directory, or admin tooling?
  4. Understand the use case:

    • Is this a new project being set up?
    • Adding to an existing LaunchDarkly integration?
    • Part of a multi-service architecture?
    • Need for project cloning across regions/teams?

Step 2: Assess the Situation

Based on your exploration, determine the right approach:

Scenario Recommended Path
New project, no LaunchDarkly integration Quick Setup - Create the project with create-project, then save its SDK keys
Existing LaunchDarkly usage Add to Existing - Create new project or use existing
Multiple services/microservices Multi-Project - Create projects per service
Multi-region or multi-tenant Project Cloning - Clone template project
Infrastructure-as-Code (IaC) setup Automated Setup - Script-based creation
Need project management tooling CLI/Admin Tools - Build project management utilities

Step 3: Choose Your Implementation Path

Select the reference guide that matches your stack and use case:

By Language/Stack:

By Use Case:

Step 4: Implement the Integration

Follow the chosen reference guide to implement project management. Key considerations:

  1. API Authentication:

    • Store API token securely
    • Follow existing secrets management patterns
    • Never commit tokens to version control
  2. Project Naming:

    • Use consistent, descriptive names
    • Follow existing naming conventions
    • Project keys: lowercase, hyphens, start with letter
  3. SDK Key Management:

    • Extract and store SDK keys for each environment
    • Save the key the application uses as LD_SDK_KEY. The Python and Node.js AI SDKs read that variable and initialize on the first AI call. They don't read LAUNCHDARKLY_SDK_KEY.
    • Use the same pattern as other secrets in your codebase
    • Consider separate keys for test/staging/production
  4. Error Handling:

    • Handle existing projects gracefully (409 conflict)
    • Provide clear error messages
    • Don't fail silently

Step 5: Verify the Setup

After creating the project, verify it works:

  1. Fetch to confirm it exists. Call the get-projects MCP tool and check that the project has its environments. Code without MCP access can call the REST API instead:

    curl -X GET "https://app.launchdarkly.com/api/v2/projects/{projectKey}?expand=environments" \
      -H "Authorization: {api_token}"

    Do not pipe the response straight into a .environments.items[]-style jq filter. The shape of environments varies by expand parameter — sometimes it's {items: [...]}, sometimes a bare array — and a hand-rolled filter will fail with Cannot index array with string "items". Run jq -e . first to inspect the actual shape, or use jq '.environments | if type == "object" then .items else . end' to handle both.

  2. Test SDK integration: Put the key in .env as LD_SDK_KEY, then initialize the AI SDK from the project directory. Python needs pip install launchdarkly-server-sdk launchdarkly-ai-server python-dotenv:

    import asyncio
    from dotenv import load_dotenv
    from launchdarkly_ai_server import init_client, get_client, shutdown
    
    load_dotenv()
    
    async def main():
        await init_client()
        print("SDK initialized:", get_client().is_initialized())
        # shutdown() flushes pending events before closing the connection.
        await shutdown()
    
    asyncio.run(main())

    Node.js needs npm install @launchdarkly/ai-node dotenv:

    import 'dotenv/config';
    import { initClient, shutdown } from '@launchdarkly/ai-node';
    
    // Resolves once connected; throws LDTimeoutError if the key is invalid
    await initClient();
    console.log('SDK initialized: true');
    await shutdown();

    A valid key prints SDK initialized: True (Python) or true (Node.js). With an invalid key, Python logs HTTP error 401 (invalid SDK key) and prints False, and Node.js throws LDTimeoutError after 10 seconds. With no key, both raise an error that asks for LD_SDK_KEY.

  3. Report results:

    • ✓ Project exists and has environments
    • ✓ SDK keys are present and valid
    • ✓ SDK can initialize (or flag any issues)

Project Key Best Practices

Project keys must follow these rules:

✓ Good examples:
  - "support-ai"
  - "chat-bot-v2"
  - "internal-tools"

✗ Bad examples:
  - "Support_AI"     # No uppercase or underscores
  - "123-project"    # Must start with letter  
  - "my.project"     # No dots allowed

Naming Recommendations:

  • Keep keys short but descriptive
  • Use team/service/purpose as naming scheme
  • Be consistent across your organization

Common Organization Patterns

By Team

platform-ai       → Platform Team Agent
customer-ai       → Customer Success Team Agent
internal-ai       → Internal Tools Team Agent

By Application/Service

mobile-ai         → Mobile App configs
web-ai            → Web App configs
api-ai            → API Service configs

By Region/Deployment

ai-us             → US Region
ai-eu             → Europe Region
ai-apac           → Asia-Pacific Region

Edge Cases

Situation Action
Project already exists Check if it's the right one; use it or create with different key
Need multiple projects Create separately for each service/region/team
Shared configs across services Use same project, separate by SDK context
Token lacks permissions Request projects:write or use MCP server
Project name conflict Keys must be unique, names can be similar

What NOT to Do

  • Don't create projects without understanding the use case first
  • Don't commit API tokens or SDK keys to version control
  • Don't use production SDK keys in test/development environments
  • Don't create duplicate projects unnecessarily
  • Don't skip the exploration phase

Next Steps

After setting up projects:

  1. Create configs - Use the configs-create skill
  2. Set up SDK Integration - Use the sdk-install skill
  3. Configure Targeting - Use the configs-targeting skill

Related Skills

  • configs-create - Create configs in projects
  • sdk-install - Integrate SDK in your application
  • configs-targeting - Configure config targeting
  • configs-variations - Manage config variations

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 warning11d3 checks · Risk SAFE
  • Gen Agent Trust Hub15d

    The LaunchDarkly Config Projects Skill is a legitimate development tool for managing LaunchDarkly projects and SDK integration. It provides cross-language implementation templates and automation guides for project creation and environment configuration. All external network interactions are directed to official LaunchDarkly infrastructure, and the skill follows industry-standard security practices for secret management.

  • Socket11d

    1 alert: gptAnomaly

  • Snyk15d

    Risk: LOW · No issues

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 2 weeks ago
metadata
{
  "author": "launchdarkly",
  "version": "0.5.0"
}
Other metadata
compatibility
Requires the remotely hosted LaunchDarkly MCP server. Code that creates projects itself (scripts, IaC, admin tools) needs an API access token with projects:write permission.
  • Python
  • Go
  • Infrastructure
  • launchdarkly
  • project-setup
  • api-integration
  • nodejs
  • configuration-management
  • feature-flags
  • secrets-management

README badge

README badge for launchdarkly/ai-tooling/projects

Guides setup of LaunchDarkly projects in a codebase by exploring the stack, assessing architecture, and choosing the right implementation path. Supports Python, Node.js, Go, and polyglot setups, with reference guides for quick setup, environment configuration, project cloning, and infrastructure automation.

Generated from the current SKILL.md.

What permissions do I need to set up LaunchDarkly projects?
Your API access token must have the projects:write permission, or you can use a LaunchDarkly MCP server configured in your environment instead.
Can the skill automatically detect my LaunchDarkly API key?
Yes. The skill checks for LAUNCHDARKLY_API_KEY, LAUNCHDARKLY_API_TOKEN, or LD_API_KEY environment variables, and also checks the Claude MCP config at ~/.claude/config.json before prompting you for the key.
What project key format is required?
Project keys must start with a letter, use only lowercase letters, numbers, and hyphens, and cannot contain uppercase letters, underscores, or dots.
Does this skill create the projects, or just guide me?
The skill guides you through the setup process and follows reference implementations for your tech stack (Python, Node.js, Go, etc.), but you choose which reference path to execute based on your architecture.
What should I do after projects are created?
After setup, verify the project exists and SDK keys are valid, then proceed to the configs-create skill to create feature flags or the sdk skill to integrate into your application.

Generated from the current SKILL.md. These answers refresh after source changes.