Continuous improvement
Continuous improvement is an ongoing process of evaluating outcomes and making successive changes to improve a system, process, or result.
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
- Improves an agent’s initial output or execution plan through repeated model feedback and revision.
- How deep it goes
- Specifies generation, same-model feedback, revision, and a stopping condition, while leaving the stopping rule and implementation details open.
- Examples
- Illustrates reflection on an external-trends subtask for a product roadmap update.
- What you can do after
- Practice/perform a bounded feedback-and-revision loop for an agent output while requiring confirmation before high-stakes actions.
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 to refine AI-generated code and prompts during focused API-development tasks.
- How deep it goes
- Explains a repeatable cycle of decomposition, generation, review, prompt refinement, and sanity checking.
- Examples
- Demonstrates Python requests through HTTP GET initialization, response display, and checks for network, timeout, and status-code failures.
- What you can do after
- Diagnose/debug with it by reviewing generated API code, identifying shortcomings, and directing successive 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-assisted analysis and communication among users, developers, management, and auditors.
- How deep it goes
- Describes prompt revision, output checking, and stakeholder feedback categories rather than a formal improvement algorithm.
- Examples
- Uses monthly review-score proportions, a cautiously interpreted seasonal signal, and reports of edge cases and technical problems.
- What you can do after
- Practice/perform it by revising requests after inspecting results and routing observed model problems to the people who can act.
Read how Starting Data Analytics with Generative AI and Python 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.
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 improve search matching and ranking rather than leaving repeated queries governed only by static tuning.
- How deep it goes
- Traces signal collection through learned-model deployment and repetition, but does not specify a training algorithm or implementation.
- Examples
- Uses an “ipad” query followed by a click and purchase, plus ratings and purchases as possible feedback signals.
- What you can do after
- Evaluate/understand how logged interactions can update future rankings while recognizing over-personalization and privacy risks.
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 deployment and refinement of enterprise generative-AI applications whose outputs can vary.
- How deep it goes
- Describes small-project iteration, retrieval feedback, fine-tuning comparisons, and the RLHF feedback mechanism without detailing an end-to-end operating procedure.
- Examples
- Uses an unsatisfactory retrieval response to motivate changing chunking and compares successive fine-tuned models against a baseline.
- What you can do after
- Practice/perform iterative evaluation and targeted refinement before scaling an application or selecting a fine-tuned model for deployment.
Read how Generative AI in Action 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 →
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.
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 →
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 →
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 →
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 →
Related concepts
- AI agentused by · An AI agent is a computational system that uses artificial intelligence to interpret information, select actions, and pursue goals through interaction with an environment.
- refactoringcontrasts with · Refactoring is the restructuring of existing software or code to change its internal organization and improve its design, typically while preserving externally observable behavior.
- agile software developmentused by · Agile software development is an iterative approach that delivers software incrementally through collaboration, feedback, adaptive planning, and responsiveness to change.
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.