October 2026 Summaries

10 posts from LaunchDarkly

Filter
Month: Year:
Post Summaries Back to Blog
Release automation, or application release automation, extends deployment processes by automating the movement of tested software artifacts through environments and controlling their exposure to users in production. It includes consistent artifact promotion, version-controlled environment configuration to prevent drift, and coordinated approvals and audit records, while developer-focused workflows can also automate versioning, changelogs, tagging, and publishing. The approach distinguishes deploying code from releasing it, enabling teams to use blue-green deployments, canaries, or feature flags to limit exposure and roll back changes without redeployment; feature flags can further support progressive delivery by advancing or halting rollouts based on performance metrics. The text argues that these runtime controls are increasingly important as AI tools accelerate code production but may also increase delivery instability, citing survey and industry findings on faster development alongside frequent rollbacks. Reported benefits include lower change failure rates, faster recovery, smaller incident impact, and more frequent releases, with examples of organizations using standardized pipelines and flags to reduce manual work and increase release volume.
Oct 30, 2026 1,936 words in the original blog post.
Jonathan Nolen, Chief Product Officer at LaunchDarkly, argues that AI agents are reshaping software development by enabling code generation faster than teams can manually review it, making rapid validation and risk control essential. He recommends increasing automated testing while using controlled releases, such as internal rollouts, synthetic testing, beta cohorts, monitoring, and feature controls, to contain production problems quickly. Nolen suggests measuring success by the amount of valuable software delivered per unit of human attention, reserving human involvement for decisions requiring judgment. Organizations should begin agent-led software factories with low-risk bug fixes before expanding to features and larger projects, supported by deployment, observability, and runtime-control tools. He also emphasizes assessing how quickly and precisely teams can reverse or disable faulty releases, since granular controls can avoid rolling back unrelated work. As coding becomes less constrained by time and cost, Nolen expects teams to increasingly build, release, measure, and refine products in rapid feedback loops, with agents eventually using production signals to help correct and optimize their own work.
Oct 30, 2026 774 words in the original blog post.
An AI software factory is presented as a repeatable, human-governed system in which builder agents move code from specifications through testing, review, deployment, and monitored release, while product agents can alter live behavior through changes to prompts, models, tools, or data sources. The central challenge is maintaining control as AI agents increase code output faster than teams can review it, with cited industry data associating higher AI adoption with larger pull requests, longer review times, and more defects and incidents. The approach emphasizes documenting requirements and test evidence alongside each change, testing actual behavior rather than appearance alone, and using gradual, metric-based rollouts with automatic rollback options. It distinguishes deploying code from exposing it to users and argues that production controls must also cover agent configurations that can change without a new deployment. LaunchDarkly positions its feature flags, guarded rollouts, AgentControl, observability, evaluations, and experimentation tools as a way to manage both code exposure and live AI-agent configurations, enabling teams to monitor outcomes, compare variations, and reverse regressions while retaining human approval where needed.
Oct 26, 2026 1,879 words in the original blog post.
Frontier AI labs are seeking to increase software delivery speed while limiting the risks of agent-generated code through layered safeguards rather than relying exclusively on human code review. A central approach is to classify changes by risk and use feature flags as the final production-facing defense, allowing teams to test changes with real traffic, limit exposure, monitor outcomes, and roll back problems quickly. The argument is that conventional, casual flag use—reserved for major launches or kill switches—is inadequate when agents substantially increase code volume and uncertainty. Instead, more changes should be flagged and released through structured, progressive plans that target defined audiences, use guardrail metrics, support approvals when needed, and enable automated rollback, diagnosis, and fixes. Because manually managing this process would add substantial friction, the proposed model emphasizes automating the full flag lifecycle, enabling agents to create flags, assess risk, choose release strategies, monitor production behavior, and remove flags after successful deployment.
Oct 21, 2026 1,432 words in the original blog post.
AI agents often remain constrained by human review and slow approval processes because their behavior can change unpredictably with updates to models, prompts, tools, or data sources, making traditional deterministic software practices insufficient. Conventional operational metrics such as cost, latency, token use, and tool failures do not measure whether an agent’s output is substantively correct, so teams are encouraged to define quality criteria, use model-based evaluation on production traffic, and focus human review on flagged cases. When quality declines, manual investigation and deployment cycles can leave users exposed to failures, whereas predefined automated responses such as reverting to a known-good configuration, using a simpler fallback, or escalating to a human can limit risk quickly. Continuous improvement is also hindered when every modification requires lengthy testing and approval, so teams can instead evaluate changes against real production examples, gradually test them alongside existing versions, and automatically roll them back if quality falls. The broader argument is that organizations need processes that can measure output quality, respond rapidly to degradation, maintain records of changes, and make small reversible improvements in order to deploy more capable and trustworthy agents.
Oct 03, 2026 1,272 words in the original blog post.
Feature engineering is presented as a central determinant of production machine-learning performance, transforming raw data into meaningful, reliable inputs through derived behavioral variables, categorical encodings, numerical scaling, temporal aggregates, and suitable representations for deep learning and text. Effective practice begins with understanding data provenance, semantics, availability, and the data-generating process to prevent leakage, bias, missing-data errors, and unstable correlations. The material emphasizes implementing preprocessing as versioned, reproducible code; fitting parameters only on training data; maintaining point-in-time correctness for temporal features; and using identical transformations in training and serving to avoid skew. It also discusses selecting features according to model and operational constraints, monitoring feature quality and drift, and using feature stores to centralize definitions, lineage, governance, and consistent offline and online access. Finally, it describes feature flags and runtime configuration tools such as LaunchDarkly as mechanisms for gradually testing inference-time changes, including feature sets, model variants, prompts, and LLM-based extraction schemas, while logging configurations to preserve reproducibility and enable safe rollback.
Oct 03, 2026 3,984 words in the original blog post.
AI governance is presented as an ongoing operational discipline for keeping production AI systems safe, reliable, and accountable as user behavior, data sources, models, and dependencies change over time. Its seven connected pillars are fairness and bias mitigation, implementable policies and procedures, data governance, privacy and data protection, risk management, monitoring and evaluation, and runtime configuration management. The approach emphasizes defining measurable fairness outcomes, testing and monitoring performance across user cohorts, restricting and tracing approved data sources, minimizing sensitive-data exposure, and enforcing authorization through application controls rather than relying on the model. It also recommends identifying failure modes, applying layered safeguards, preparing restricted fallback modes, and using offline tests alongside live quality, safety, cost, and reliability signals to guide staged rollouts. Versioned prompts, model settings, tool permissions, and routing rules—with audit trails, controlled experiments, and rapid rollback capabilities—are described as central mechanisms for connecting governance requirements to day-to-day production operations and supporting compliance with external standards and regulations.
Oct 03, 2026 4,126 words in the original blog post.
Managing AI features that rely on hosted models requires a lifecycle distinct from conventional code deployment because teams must frequently adjust model selection, prompts, parameters, targeting, and safeguards without redeploying applications. The described approach centers on externalizing these decisions into versioned runtime configurations, evaluating proposed variations against representative and adversarial datasets with calibrated LLM-based judges, and releasing changes gradually to targeted audiences while monitoring quality, cost, latency, token usage, and errors. Guarded rollouts and automatic rollback can limit the effects of regressions, while production evaluation samples live traffic to identify issues not captured in pre-production testing. Experimentation complements quality evaluation by measuring whether model changes improve business outcomes such as conversion or task completion, with consistent variation assignment needed for reliable attribution. The article presents LaunchDarkly AgentControl as an integrated implementation of these capabilities, combining managed model and prompt configurations, playground-based evaluation, audience targeting, rollout controls, monitoring, adaptive fallbacks, and experimentation, while emphasizing that production failures should become future test cases in a continuous feedback loop.
Oct 03, 2026 3,192 words in the original blog post.
A tutorial describes how to build a small AI-assisted software factory in GitHub using seven stations that move work from a structured issue to verified production: intake, context, planning, execution, review and policy, delivery, and observability. The approach uses issue templates to define goals, constraints, and completion criteria; a maintained CLAUDE.md file to provide repository context; read-only agents to propose plans for human approval; and coding agents with limited permissions to implement approved work and open pull requests. Independent safeguards include rerunning tests, linting, and type checks outside the agent, enforcing branch protections and policies that prevent agents from changing factory configuration, and using a separate reviewer agent to inspect code and test coverage. After human-approved merges, smoke tests validate the deployed application and can automatically create a revert pull request if failures occur, while prompts, plans, and transcripts are retained as artifacts for traceability. Using a URL-shortening application as an example, the tutorial reports that a change adding 30-day link expiration moved from planning through verified deployment in minutes, while emphasizing that the most important part of an AI software factory is its ability to reject unsafe or incorrect changes at every stage.
Oct 03, 2026 2,457 words in the original blog post.
A robust production machine learning architecture separates a data layer, which creates and versions validated inputs, features, and AI-generated outputs, from a runtime layer that controls deployment of trained model artifacts through feature flags. The model artifact connects these layers by recording the exact datasets, feature definitions, code, environments, prompts, models, parameters, and tool configurations used during training, ensuring reproducibility and preventing training-serving skew. AI-generated features such as summaries, classifications, and embeddings must be treated like conventional feature transformations: tested offline, version-locked, pinned in training manifests, and never changed for a deployed downstream model without retraining. The pipeline should validate both raw and transformed data, preserve point-in-time correctness, maintain consistent offline and online feature definitions, and use artifact-based handoffs to support auditing, debugging, and reruns. Candidate models should be promoted through staged, guarded rollouts that shift traffic gradually while monitoring model quality, operational reliability, AI-step metrics, and business outcomes, with feature flags serving as the single runtime release control and enabling rapid rollback. Continuous monitoring should capture model and AI-feature versions, predictions, relevant inputs, system health, drift, and eventual outcomes so teams can distinguish regressions caused by data, features, AI configurations, or model versions.
Oct 03, 2026 4,288 words in the original blog post.