Continuous improvement
Continuous improvement is a recurring process in which outcomes or feedback guide successive changes intended to improve a system, process, or result.
Build High Value Software Systems
A feedback loop is a process in which information about outcomes is returned to influence subsequent decisions or actions.
- How it is used
- Uses recurring delivery friction to guide small changes to workflows, tools, standards, and feedback loops.
- How deep it goes
- Details an observe-measure-change-remeasure cycle, including baselines, short trials, side effects, and decisions to standardize or revert.
- Examples
- Works through CI caching, review delays, deployment automation, and a pre-commit lint-hook experiment.
- What you can do after
- Practice/perform a measured improvement cycle on personal or team workflows, then keep, revise, or revert the change.
Read how Build High Value Software Systems explains continuous improvement →
The Art of AI Product Development
Self-refinement is an iterative technique in which a model critiques and improves its own generated outputs.
- How it is used
- Uses self-refinement to improve agent plans and model outputs through repeated feedback and revision.
- How deep it goes
- Describes the generate-feedback-revise loop and a stopping condition, without specifying how to choose that condition.
- Examples
- Illustrates refinement with a road-mapping agent identifying relevant generative AI trends.
- What you can do after
- Evaluate and understand how a model can critique and revise its own output during a complex task.
Read how The Art of AI Product Development explains continuous improvement →
Coding with AI
Iterative evaluation is the repeated assessment of generated results followed by changes intended to improve their quality or accuracy.
- How it is used
- Uses repeated evaluation and revision to improve AI-generated code and prompts.
- How deep it goes
- Details an initial prompt, response critique, recursive input, and repeated refinement, with further refinement optional.
- Examples
- Refines a Python factorial function and works through a Python application failing inside a Docker container.
- What you can do after
- Apply iterative refinement by reviewing a response and requesting specific corrections or improvements.
Starting Data Analytics with Generative AI and Python
A feedback loop is a recurring cycle in which information about outcomes is communicated back to participants to guide improvements or decisions.
- How it is used
- Guides repeated refinement of AI-supported analysis and feedback among people responsible for model use and oversight.
- How deep it goes
- Outlines a refinement cycle and stakeholder feedback categories, including context limitations and decisions about model development.
- Examples
- Uses monthly review-score proportions and reports of edge cases, downtime, adoption, and costs as examples of information for improvement.
- What you can do after
- Apply it through iterative AI queries and stakeholder feedback to refine outputs and inform development decisions.
Read how Starting Data Analytics with Generative AI and Python explains continuous improvement →
AI Model Evaluation
A dynamic process in which a model's predictions influence user behavior and that behavior changes the data observed by the model later.
- How it is used
- Frames model evaluation as measurement of a changing system whose outputs shape user behavior and future data.
- How deep it goes
- Explains the feedback cycle, evaluation pitfalls, and safeguards, including exploration and holdout trade-offs.
- Examples
- Uses a political news feed to illustrate how engagement can reinforce recommendations over time.
- What you can do after
- Evaluate and understand feedback-driven metric changes using exploration, long-term holdouts, and measures beyond short-term engagement.
Read how AI Model Evaluation explains continuous improvement →
AI Agents in Action
A feedback loop is a control pattern in which outcome information is used to modify subsequent actions or plans.
- How it is used
- Guides planning agents to correct subsequent actions and improve performance using feedback.
- How deep it goes
- Outlines task-by-task feedback integration and comparison, and surveys feedback timing and placement across applications.
- Examples
- Uses a time-travel puzzle with corrective prompting and an exercise gathering data from multiple sources.
- What you can do after
- Practice adding a feedback loop to a sequential planning agent and comparing its behavior before and after integration.
Read how AI Agents in Action explains continuous improvement →
Build a Reasoning Model (From Scratch)
An inference-time procedure that iteratively revises a model answer and keeps a revision only if it scores better than the current answer.
- How it is used
- Improves a single generated answer during inference without changing model weights, trading additional compute and latency for potential accuracy gains.
- How deep it goes
- Descends from prompts and workflow to reusable multi-iteration code, heuristic scoring, token log probabilities, and score-based acceptance.
- Examples
- Uses an algebra correction, rule-based answer ranking, average-logprob scoring, refinement traces, and MATH-500 accuracy comparisons.
- What you can do after
- Build it from scratch as a prompted generation loop with configurable iterations, scoring functions, sampling settings, and revision acceptance.
Read how Build a Reasoning Model (From Scratch) explains continuous improvement →
Think Like a Software Engineering Manager
A feedback loop is a recurring process in which information about results or behavior informs subsequent actions or adjustments.
- How it is used
- Uses recurring feedback to improve cross-functional collaboration, project delivery, retention decisions, and organizational change.
- How deep it goes
- Lays out feedback channels and a monitor-evaluate-adjust cycle, without prescribing a fixed cadence or measurement method.
- Examples
- Illustrates improvement through stakeholder one-on-ones, anonymous surveys, exit interviews, and iterative cloud migration.
- What you can do after
- Practice/perform it by collecting feedback, identifying trends, adjusting plans, and checking results again.
Read how Think Like a Software Engineering Manager explains continuous improvement →
Effective Platform Engineering
An iterative development cycle is a repeated, bounded period in which a team plans, builds, evaluates, and improves a software increment.
- How it is used
- Guides platform teams in delivering capabilities incrementally and adapting the roadmap to user feedback.
- How deep it goes
- Describes short sprints, reviews, retrospectives, cross-functional participation, and feedback collection rather than prescribing a fixed sprint schedule.
- Examples
- Uses a deployment-automation MVP, subsequent testing and rollback features, surveys, interviews, and sprint retrospectives.
- What you can do after
- Practice/perform it by releasing small platform increments, evaluating delivery measures and user feedback, then adjusting the next sprint.
Read how Effective Platform Engineering explains continuous improvement →
Shipping Go: Develop, deliver, discuss, design, and go again
A feedback cycle is a recurring process in which outcomes or evaluations inform corrective action and subsequent improvement.
- How it is used
- Uses recurring developer, customer, and process feedback to guide changes after each increment of delivery.
- How deep it goes
- Explains the develop–deliver–discuss–design cycle and gives metrics-led process-review guidance, without prescribing a fixed improvement procedure.
- Examples
- Illustrates feedback with compilation or quality-check failures, customer reactions after delivery, and delivery-time and build-time metrics.
- What you can do after
- Practice/perform it by acting on pipeline and customer feedback and periodically evaluating the delivery process with metrics.
Retrieval Augmented Generation, The Foundational Ideas
A closed-loop system observes an intermediate or resulting state and uses that evaluation to decide subsequent actions.
- How it is used
- Turns retrieval, answering, and production evaluation failures into decisions about what to retry, train, or change.
- How deep it goes
- Details query-time and production-loop steps, plus reader-guided retriever training; leaves loop selection dependent on failure diagnosis and latency.
- Examples
- Uses a compliance assistant’s weekly tests and reranking-to-grounding-prompt iterations to expose metric tradeoffs.
- What you can do after
- Operate/configure a RAG feedback cycle by collecting signals, diagnosing failures, applying targeted fixes, and checking for regressions.
Read how Retrieval Augmented Generation, The Foundational Ideas explains continuous improvement →
Collaborative Software Design: How to facilitate domain modeling decisions
A cycle in which information about outcomes or requirements feeds back into subsequent decisions or actions.
- How it is used
- Keeps collaborative design and decision-making responsive to new information, perspectives, requirements, and implementation conditions.
- How deep it goes
- Explains iterative modeling, participant changes, reflection, sharing, and redesign, but stops short of prescribing a fixed loop or cadence.
- Examples
- Uses repeated EventStorming, asynchronous decision comments, distilled diagrams, and Eric Evans’s Model Exploration Whirlpool.
- What you can do after
- Apply iterative modeling to gather evidence, lower uncertainty, challenge assumptions, and revise decisions without preserving unsuitable designs.
Sutskever's List
A recurrent feedback loop feeds information from a previous time step back into a neural network's computation at the current step.
- How it is used
- Explains how recurrent neural networks retain context while processing text, audio, and other sequences.
- How deep it goes
- Explains the per-step inputs and hidden-state update, without deriving equations or training dynamics.
- Examples
- Uses character-by-character text generation, prediction after “hel,” and a chain diagram.
- What you can do after
- Evaluate/understand why a recurrent neural network can use earlier sequence elements when producing a current output.
AI-Powered Search
Iterative refinement is the progressive improvement of a task result through successive revisions based on new information or feedback.
- How it is used
- Uses feedback loops to continually improve search matching, ranking, and personalization.
- How deep it goes
- Traces signals from queries through relevance-model deployment, while mentioning conversational refinement without an implementation.
- Examples
- Illustrates learning from an “ipad” query, a clicked result, and a product purchase.
- What you can do after
- Evaluate and understand search feedback loops and their personalization trade-offs.
Read how AI-Powered Search explains continuous improvement →
Generative AI in Action
A development method that repeatedly evaluates outcomes and refines a system through successive cycles.
- How it is used
- Guides gradual enterprise generative AI adoption and refinement through evaluation and feedback.
- How deep it goes
- Describes evaluation and adjustment cycles for chunking and fine-tuning, including fallback strategies and iteration costs.
- Examples
- Uses unsatisfactory retrieval responses to motivate alternative chunking and compares fine-tuned models against task baselines.
- What you can do after
- Evaluate and refine generative AI systems using feedback, task criteria, and baseline comparisons.
Read how Generative AI in Action explains continuous improvement →
Software Architecture Decision-Making
A feedback loop is a recurring cycle in which information about results or changing conditions informs subsequent system decisions or adaptations.
- How it is used
- Frames architecture as an ongoing response to consequences, changing constraints, and failing assumptions.
- How deep it goes
- Explains signals, sensing mechanisms, response options, and a small-scale starting approach rather than prescribing a formal process.
- Examples
- Uses fragile modules, breaking integrations, recurring incidents, workarounds, and rewrite discussions as change signals.
- What you can do after
- Evaluate/understand when architectural assumptions are failing and choose deferral, adaptation, or replacement deliberately.
Read how Software Architecture Decision-Making explains continuous improvement →
Lead Developer Career Guide
A recurring process in which information about results or progress is returned to guide subsequent decisions or actions.
- How it is used
- Uses recurring feedback to adjust project decisions, coordinate teams, and develop leadership skills.
- How deep it goes
- Explains practical feedback routines and their rationale through situations; does not prescribe a formal improvement framework.
- Examples
- Illustrates adjustments through client milestones, confusing deployment notifications, and feedback after shadowing a lead developer.
- What you can do after
- Practice/perform it by seeking feedback, clarifying the next step, and adjusting priorities or working methods.
Read how Lead Developer Career Guide explains continuous improvement →
LLM Evaluation and Alignment, The Foundational Ideas
An approach to system development that repeatedly cycles through designing, measuring, and improving a system.
- How it is used
- Guides AI system development by linking evaluation of behavior to alignment interventions.
- How deep it goes
- Breaks the cycle into criteria, measurement, error analysis, and alignment, then demonstrates each step with a chatbot.
- Examples
- Uses an e-commerce chatbot with null shipping data, prompt changes, retrieval, and measured accuracy across 500 conversations.
- What you can do after
- Apply the cycle by defining criteria, measuring behavior, diagnosing error patterns, and choosing targeted alignment interventions.
Read how LLM Evaluation and Alignment, The Foundational Ideas explains continuous improvement →
Vibe Engineering
A feedback loop is a pattern in which information about an output or system state is fed back into subsequent evaluation or action.
- How it is used
- Turns engineering checks and production signals into evidence for improving AI-assisted development and software systems.
- How deep it goes
- Explains checks, staged production responses, and an ideal autonomous cycle, while noting that full autonomy remains unrealized.
- Examples
- Uses meaningful tests, linting, CI checks, production anomaly tickets, and canary verification as feedback mechanisms.
- What you can do after
- Evaluate and strengthen feedback channels using independent specifications, automated checks, production signals, and operational safeguards.
Designing AI Systems
An asynchronous improvement loop evaluates completed interactions after serving them and feeds the resulting scores into systematic system improvement.
- How it is used
- Connects observability signals to systematic changes through scoring, evaluation, and production experiments.
- How deep it goes
- Details a cycle from trace scoring through dataset curation and offline evaluation to A/B testing, without specifying scoring implementations.
- Examples
- Uses completed patient-intake traces to illustrate asynchronous scoring and experiment-variant comparison.
- What you can do after
- Operate a feedback cycle that scores live traffic, compares alternatives, and feeds results into production decisions.
Read how Designing AI Systems explains continuous improvement →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A development cycle consisting of a small code change followed by evaluation and possible correction.
- How it is used
- Uses small, tested changes to guide development and manage larger efforts such as monolith conversion and infrastructure prototyping.
- How deep it goes
- Describes a practical change-and-test cycle, emphasizing feedback, working code, and incremental complexity.
- Examples
- Uses incremental monolith-to-microservices conversion and repeated Terraform apply-and-test cycles as examples.
- What you can do after
- Practice the cycle by making a small code or Terraform change, testing its result, and using feedback to choose the next step.
AI Recommender Systems
A feedback loop is a cycle in which system outputs prompt user interactions that are logged and fed back to improve subsequent outputs.
- How it is used
- Uses logged responses to recommendations as data for improving future recommendations.
- How deep it goes
- Traces recommendation, interaction, logging, and model training, then identifies signal quality and bias challenges without specifying a retraining procedure.
- Examples
- Illustrates reinforcement with Asterix gaining interactions while Little Frog struggles for visibility in a comic catalog.
- What you can do after
- Evaluate/understand how interaction data can adapt recommendations while amplifying exposure bias or leaving new users and items without history.
Read how AI Recommender Systems explains continuous improvement →
Effective Conversational AI
A feedback loop is a process in which observed results or user information are fed back into a system to refine its behavior.
- How it is used
- Improves conversational AI by turning observed performance into measured changes that support effective user experiences.
- How deep it goes
- Details a measured change-and-review cycle, including prioritization, monitoring, retraining, and test-set updates.
- Examples
- Uses classifier test-and-train cycles, password-synonym prompt experiments, and changing user questions as examples.
- What you can do after
- Diagnose weak understanding, prioritize changes, measure their effects, and refresh tests as system coverage changes.
Read how Effective Conversational AI explains continuous improvement →
Machine Learning System Design
A feedback loop is a pattern in which a model or system affects the data-generating process that later supplies its inputs or labels.
- How it is used
- Frames feedback loops as a data-provenance concern and a complication in online testing.
- How deep it goes
- Explains the mechanism through recommender examples and flags metadata limits and missing counterfactuals.
- Examples
- Uses marketplace recommendations that reinforce an item's popularity over time.
- What you can do after
- Evaluate online recommender results cautiously by recognizing that historical data omits alternative exposures.
Read how Machine Learning System Design explains continuous improvement →
Optimization Algorithms: AI techniques for design, planning, and control problems
A closed-loop system is a control system that measures its output and uses feedback to adjust its input toward a desired value.
- How it is used
- Uses measured output as feedback to adjust inputs toward a desired state.
- How deep it goes
- Defines feedback, explains PID terms, and demonstrates genetic-algorithm tuning of controller parameters.
- Examples
- Uses thermostat-based room-temperature control and a PID tuning example.
- What you can do after
- Apply `pymoo` and `control` to optimize PID parameters and inspect a step response.
Build AI-Enhanced Web Apps
Self-refine is a technique in which a language model generates an output, critiques it with self-provided feedback, and iteratively revises it without additional training.
- How it is used
- Improves generated outputs through self-feedback, particularly for tasks with complex or hard-to-define goals.
- How deep it goes
- Defines a repeatable generate-critique-revise loop but does not specify an implementation or stopping mechanism beyond meeting a quality standard.
- Examples
- Uses review rewriting, code optimization, structured-output reprompting, and chunk-by-chunk document summaries as examples.
- What you can do after
- Apply repeated generation, self-critique, and revision to improve an output without additional training.
Read how Build AI-Enhanced Web Apps explains continuous improvement →
First-Party Data Activation
A process in which outputs or results are fed back into subsequent decisions or actions to influence later outcomes.
- How it is used
- Uses customer feedback and campaign measurement to improve products, customer experience, targeting, content, and channel choices.
- How deep it goes
- Details a cycle of reviewing metrics, finding opportunities, refining segments and personalization, then experimenting again.
- Examples
- Uses routed support complaints, a retailer’s controlled personalization test, and AI-informed customer journeys as illustrations.
- What you can do after
- Apply it to refine campaign targeting, content, channels, and product priorities using measured results and recurring customer feedback.
Read how First-Party Data Activation explains continuous improvement →
Machines that Think
A feedback loop is a process in which a system's outputs or effects alter later inputs or data, thereby influencing subsequent system behavior.
- How it is used
- Uses feedback loops to explain both AI improvement and the reinforcement of harmful outcomes.
- How deep it goes
- Explains expert routing and its balance requirements, then surveys automated approaches to AI development without presenting a full procedure.
- Examples
- Illustrates reinforcing cycles with predictive policing, expert specialization, and AlphaEvolve’s automatically evaluated programs.
- What you can do after
- Evaluate feedback loops by distinguishing useful reinforcement from cycles that amplify bias or starve components of training data.
Read how Machines that Think explains continuous improvement →
The Coder Cafe
A feedback loop is a process in which system outputs or observations influence subsequent actions or system behavior.
- How it is used
- Uses observability to shorten feedback loops, helping teams experiment safely and continuously improve complex systems.
- How deep it goes
- Defines observability and describes its role in improvement, but gives no step-by-step feedback-loop procedure.
- Examples
- Uses an ineffective system change with unaccounted factors and proposes event replay or deterministic simulation.
- What you can do after
- Evaluate system changes using telemetry, short feedback loops, event replay, or deterministic simulation.
AI Agents in Action, Second Edition
An iterative improvement process in which an output is revised or enhanced across successive iterations.
- How it is used
- Uses feedback from actions or evaluations to adjust an agent’s next step, strategy, or output.
- How deep it goes
- Explains action-observation loops, dynamic strategy changes, and production evaluation practices, but gives no complete implementation procedure.
- Examples
- Uses iterative writing, summarization, troubleshooting, and tool-result feedback as examples.
- What you can do after
- Diagnose/debug with evaluation and feedback by measuring behavior, capturing human input, and optimizing agent performance.
Read how AI Agents in Action, Second Edition explains continuous improvement →
Architecting for Autonomy
A feedback loop is a process in which the results of previous actions influence subsequent decisions or actions.
- How it is used
- Connects autonomous runtime behavior to governance and ongoing authority decisions.
- How deep it goes
- Explains how drift or rising failure costs tighten checkpoints and delegation, while stable risk can justify expansion.
- Examples
- Uses an incident triage agent whose severity classifications drift as the worked example.
- What you can do after
- Operate an agent’s authority by adding checkpoints when drift appears and expanding delegation only when evidence supports it.
Read how Architecting for Autonomy explains continuous improvement →
Data-Driven Cybersecurity
A feedback loop is an iterative process in which outputs or observations inform subsequent adjustments to a system or process.
- How it is used
- Keeps cybersecurity analytics, metrics programs, and risk practices relevant as threats and organizational needs change.
- How deep it goes
- Moves from feedback collection through metric review and adjustment, including trend analysis, while leaving implementation organization-specific.
- Examples
- Uses recurring vulnerabilities, unpatched-vulnerability targets, incident-resolution times, and department-level incident patterns to guide changes.
- What you can do after
- Apply it by setting measurable goals, reviewing metrics and incidents, adjusting controls, and checking whether changes improve outcomes.
Read how Data-Driven Cybersecurity explains continuous improvement →
AI-Powered Developer: Build software with ChatGPT and Copilot
A feedback loop is an iterative interaction in which prior context and user reactions influence subsequent inputs and outputs.
- How it is used
- Uses successive prompts and reactions to refine AI-assisted development or security analysis.
- How deep it goes
- Explains the interaction pattern and practical refinement steps but stops short of formal process theory or implementation internals.
- Examples
- Uses coding-assistant comparisons and an e-commerce security brainstorming sequence involving containers, microservices, and attack scenarios.
- What you can do after
- Apply it via ChatGPT by challenging responses, requesting actions, documenting findings, and revisiting changed designs.
The Well-Grounded Rubyist, Fourth Edition
Iteration is a technique in which a method call is supplemented with code that the method can invoke during its execution.
- How it is used
- Uses a method-supplied code block as a control-flow technique, allowing the method to execute that code during its operation.
- How deep it goes
- Explains iterators, blocks, and yield, and contrasts iteration with execute-or-skip control flow.
- Examples
- Shows `loop { puts "Looping forever!" }` as a block passed to an iterator.
- What you can do after
- Build an iterator that invokes a supplied code block with yield.
Read how The Well-Grounded Rubyist, Fourth Edition explains continuous improvement →
Build an AI Agent (From Scratch)
A reasoning process that repeatedly evaluates intermediate results and determines subsequent steps.
- How it is used
- Uses repeated agent passes when output quality can be measured and refinement can improve the result.
- How deep it goes
- Implements sequential agent execution, context flow, stop conditions, and iteration limits.
- Examples
- Demonstrates writer-reviewer cycles for marketing copy, code testing, and translation review.
- What you can do after
- Build it from scratch with sequential agents, a measurable stop condition, and a maximum iteration count.
Read how Build an AI Agent (From Scratch) explains continuous improvement →
Build Financial Software with Generative AI (From Scratch)
An iteration is a repeated development cycle that produces progress toward a larger software objective.
- How it is used
- Improves application functionality by addressing user concerns, business needs, and technical debt across successive iterations.
- How deep it goes
- Demonstrates a table-by-table feedback loop using database, parser, and unit-test updates.
- Examples
- Uses ACH database-table and parser tests, transaction search, exception handling, and audit improvements.
- What you can do after
- Apply it by refining application features in short cycles, using user feedback, tests, and stakeholder needs to guide changes.
Architecture Modernization: Socio-technical alignment of software, strategy, and structure
Iterative development is an approach that delivers a product or capability through repeated cycles of implementation, feedback, and refinement.
- How it is used
- Guides teams to adjust the balance of discovery, design, and delivery using feedback from their work.
- How deep it goes
- Explains recurring reflection and feedback loops, but provides no fixed method for finding an optimal balance.
- Examples
- Uses avoidable roadblocks, changing priorities, and visible progress as prompts for team reflection.
- What you can do after
- Evaluate work patterns and feed delivery lessons into future discovery and design.
Build Python Web Apps with Streamlit
Iterative development is a software-development technique that repeatedly cycles through implementation, testing, evaluation, and revision.
- How it is used
- Guides app development through repeated implementation, testing, and revision, while allowing earlier project decisions to change.
- How deep it goes
- Details a repeatable coding-and-testing loop and a six-step process, while leaving each project's implementation choices open.
- Examples
- Uses a Streamlit app tested by entering values, clicking buttons, and checking browser output.
- What you can do after
- Apply it by running a Streamlit app, testing browser interactions, and revising code or earlier project decisions.
Read how Build Python Web Apps with Streamlit explains continuous improvement →
Natural Language Processing in Action, Second Edition
A cyclic processing pattern in which system outputs are fed back as inputs for further analysis.
- How it is used
- Evaluates chatbot replies by routing generated text through NLP processing and using resulting features to select a response.
- How deep it goes
- Traces reprocessing and objective-function scoring, without describing updates to model parameters.
- Examples
- Uses a chatbot pipeline in which generated replies re-enter the algorithms used for user statements.
- What you can do after
- Evaluate and select chatbot replies by combining response scores or features in an objective function aligned with dialog goals.
Read how Natural Language Processing in Action, Second Edition explains continuous improvement →
Experimentation for Engineers
A feedback loop is a cycle in which a system’s outputs influence subsequent inputs, behavior, or observations.
- How it is used
- Explains how policy decisions in contextual bandits can perpetuate biased training data and obstruct performance improvement.
- How deep it goes
- Works through a missing context-action example, identifies subtler data biases, and points to exploration without deriving its algorithms.
- Examples
- Uses User A receiving post #1, missing logged rewards, refitted Model 1m predictions, and a causal feedback-loop figure.
- What you can do after
- Diagnose feedback risks, apply exploration to gather corrective samples, and validate contextual-bandit changes with A/B tests.
Read how Experimentation for Engineers explains continuous improvement →
Grokking AI Algorithms, Second Edition
A feedback loop is a recurring process in which the consequences of actions provide signals that influence subsequent actions or behavior.
- How it is used
- Personalizes actions by using observed outcomes to adjust workouts or behavior over repeated decisions.
- How deep it goes
- Explains sensor-driven workout adjustment and reward-based learning, then connects actions to long-term consequences.
- Examples
- Uses wearable-guided training, dog-sit rewards, animal trial and error, and chocolate's short- versus long-term effects.
- What you can do after
- Understand how rewards, penalties, and body signals can shape later actions toward longer-term goals.
Read how Grokking AI Algorithms, Second Edition explains continuous improvement →
Advanced Algorithms and Data Structures
An iteration is one repetition of an algorithmic cycle or update sequence.
- How it is used
- Bounds repeated algorithm work and schedules updates during iterative optimization.
- How deep it goes
- Quantifies k-means runtime by iteration count and discusses simulated-annealing step and cooling schedules.
- Examples
- Uses a maximum iteration count for K-means and interval-based temperature updates for simulated annealing.
- What you can do after
- Evaluate how iteration limits affect K-means runtime and how update choices affect simulated-annealing search.
Read how Advanced Algorithms and Data Structures explains continuous improvement →
Building Reliable AI Systems
An ongoing process of using system information to make iterative changes that improve performance or quality.
- How it is used
- Uses monitoring insights to improve quality and reliability in production LLM systems.
- How deep it goes
- Frames the feedback loop and names update mechanisms without explaining their procedures.
- Examples
- Names A/B testing, prompt optimization, and model updates as improvement actions.
Read how Building Reliable AI Systems explains continuous improvement →
Also covered in
- "Looks Good to Me"
- The Well-Grounded Data Analyst
- Introduction to Generative AI, Second Edition
- Math and Architectures of Deep Learning
- API Design Patterns
- Knowledge Graphs and LLMs in Action
- Software Design for Python Programmers
- Enterprise RAGIn early access (MEAP)
- Digital Twins in Action
- AI Agents and Applications
- Object-Oriented Software Design in C++
- Clojure: The Essential Reference
What to know first
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- conversational aiConversational AI is artificial intelligence that enables software systems to interpret user input and interact with users through natural-language dialogue.
- accuracyAccuracy is the degree to which a result agrees with a specified truth, reference, or criterion, commonly measured as the proportion of evaluated predictions that are correct.
- promptA prompt is text or other input supplied to an AI model to provide instructions, context, or other information that guides its response or generated output.
Related concepts
- AI agentused by · An AI agent is a computational system that uses artificial intelligence to interpret information and select or perform actions toward goals while interacting with an environment.
- Andonuses · Andon is a visual signaling system that makes abnormal conditions visible and enables workers to request attention or intervention, potentially stopping work until the issue is addressed.
- Gembauses · The actual place where work occurs and value is created, viewed in Lean management as the location for direct observation.
- refactoringcontrasts with · Refactoring is the disciplined restructuring of existing software to improve its internal qualities while preserving its externally observable behavior.
- standard workuses · Standard work is an agreed method or criterion for how work should be performed.
- agile software developmentused by · Agile software development is an iterative approach to developing software through incremental delivery, collaboration, feedback, and adaptation to change.
Questions about continuous improvement
What is continuous improvement?
Continuous improvement is a recurring process in which outcomes or feedback guide successive changes intended to improve a system, process, or result.
Which Manning books explain continuous improvement?
Build High Value Software Systems, The Art of AI Product Development, Coding with AI, Starting Data Analytics with Generative AI and Python, AI Model Evaluation, AI Agents in Action, Build a Reasoning Model (From Scratch), Think Like a Software Engineering Manager and 35 more.
What should I know before learning continuous improvement?
Manning books that teach continuous improvement usually introduce language model, conversational ai, accuracy and prompt first.
What is the difference between continuous improvement and refactoring?
Continuous improvement is a recurring process in which outcomes or feedback guide successive changes intended to improve a system, process, or result. Refactoring is the disciplined restructuring of existing software to improve its internal qualities while preserving its externally observable behavior.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.










































