liveBook · Manning

Decomposition

Decomposition is the process of dividing a complex problem, task, or system into smaller constituent parts that can be handled or analyzed separately.

How 11 Manning books explain it

Learn AI-Assisted Python Programming, Second Edition

Task decomposition is the practice of dividing a large problem or program into smaller, more manageable tasks or subproblems.

How it is used
Uses decomposition to design manageable functions, guide AI coding requests, control complexity, and support testing.
How deep it goes
Explains recursive top-down breakdown, function responsibilities, implementation order, and testing, while treating decomposition as a practiced design skill.
Examples
Demonstrates spelling suggestions, word searches, quarterback data processing, image merging, and order processing.
What you can do after
Build it from scratch by designing function hierarchies, requesting focused AI-generated code, implementing dependencies bottom-up, and testing each function.

Read how Learn AI-Assisted Python Programming, Second Edition explains decomposition →

Grokking Concurrency

Data decomposition is a parallel programming technique that partitions a collection of data into independent chunks and applies the same operation to each chunk.

How it is used
Finds independent work by splitting data into chunks for the same operation.
How deep it goes
Explains independence, loop-level parallelism, and chunk granularity through practical examples.
Examples
Illustrates separate snow-clearing zones, independent file searches, and word counting across input chunks.
What you can do after
Apply it via Python's ThreadPool to search files concurrently.

Read how Grokking Concurrency explains decomposition →

Get Programming: Learn to code with Python

The technique of dividing a complex problem, task, or program into smaller, separately manageable parts.

How it is used
Organizes programming problems into manageable tasks before coding, so their pieces can be checked and combined.
How deep it goes
Works through task identification, inputs and outputs, dependencies, and reusable task design; leaves specific implementation decisions for later.
Examples
Illustrates the technique through a minutes-conversion program and an online-order workflow.
What you can do after
Practice/perform it by dividing a program into clear tasks, checking smaller pieces, and assembling them into a working whole.

Read how Get Programming: Learn to code with Python explains decomposition →

Machine Learning System Design

Decomposition is a release strategy that allows different system components to be deployed and managed independently.

How it is used
Lets ML system components follow different release strategies.
How deep it goes
Mentions component-specific releases with an example but does not detail their implementation.
Examples
Contrasts a canary release for a model with a traditional release for an API layer.
What you can do after
Evaluate component-specific release approaches and distinguish canary deployment from A/B testing.

Read how Machine Learning System Design explains decomposition →

Functional Programming in JavaScript

How it is used
Breaks complex JavaScript tasks into simple functions that can be composed into a complete functional solution.
How deep it goes
Explains function-level splitting and self-similar recursive reduction, including base and recursive cases rather than formal complexity analysis.
Examples
Uses showStudent as a composed pipeline and array summation as a recursive reduction, alongside tree and document traversal applications.
What you can do after
Apply it by splitting JavaScript operations into focused functions or smaller self-similar recursive problems.

Read how Functional Programming in JavaScript explains decomposition →

Agent Design Patterns

The division of a complex task or workflow into smaller, focused units.

How it is used
Partitions agent workflows into focused errands and large inputs into fragments that can be processed and recomposed.
How deep it goes
Explains a component hierarchy and DPR’s decomposition, processing, and recomposition data flow, including properties of fragments and final results.
Examples
Uses batched file processing, large archives, and map-reduce document summarization to illustrate focused work and fragmented-input processing.
What you can do after
Apply it via Errand and DPR patterns to organize agent actions or process large inputs as focused, recomposable units.

Read how Agent Design Patterns explains decomposition →

The Art of AI Product Development

Task decomposition is the process of breaking a complex objective into smaller subtasks that can be planned or executed separately.

How it is used
Structures language-model reasoning and agent execution around smaller, manageable tasks.
How deep it goes
Explains decomposition and partial solution generation through a writing workflow, then discusses agent planning trade-offs and limitations.
Examples
Uses a blog-writing workflow and a finance agent’s safeguards for high-stakes transactions.
What you can do after
Apply it to prompt workflows and agent plans while accounting for execution risks and human review.

Read how The Art of AI Product Development explains decomposition →

AI Agents in Action, Second Edition

How it is used
Distinguishes the work of identifying subtasks from planning their order, dependencies, and approach.
How deep it goes
Defines decomposition and contrasts it with planning, then connects novel subtasks to adaptive agent orchestration.
Examples
Uses leaving home as a simple sequence and research orchestration as an adaptive task-delegation case.
What you can do after
Evaluate whether an agent invents subtasks for novel problems instead of treating complex queries as flat lookups.

Read how AI Agents in Action, Second Edition explains decomposition →

Coding with AI

Problem decomposition is the division of a complex task into smaller, manageable subtasks.

How it is used
Uses decomposition to turn troubleshooting or implementation goals into sequential prompts and manageable questions.
How deep it goes
Explains decomposition through subtasks, prompt design, and iterative evaluation, using an HTTP request as the worked scenario.
Examples
Uses container troubleshooting and a Python requests API call, including response display and network or status errors.
What you can do after
Apply it via sequential prompts to plan an HTTP GET request and guide focused follow-up questions.

Read how Coding with AI explains decomposition →

Grokking AI Applications

A problem-solving technique that divides a complex request into smaller, ordered subtasks.

How it is used
Improves prompt accuracy and alignment by turning complex LLM requests into manageable, structured steps.
How deep it goes
Defines the technique and demonstrates one business-plan prompt, then connects it to step-by-step reasoning.
Examples
Uses a business-plan request that first lists sections and then outlines each section’s goals.
What you can do after
Apply it via an LLM-based assistant to convert broad requests into clearer, sequential prompts.

Read how Grokking AI Applications explains decomposition →

Learn Concurrent Programming with Go

Task decomposition is the technique of dividing a computation into distinct units of work that can be assigned or coordinated independently.

How it is used
Frames concurrent-program design by separating independent actions from dependencies before selecting implementation patterns.
How deep it goes
Explains task lists, dependency graphs, task-versus-data decomposition, and granularity trade-offs, then defers implementation patterns.
Examples
Uses a flat-tire repair workflow and web-page word processing to illustrate parallel actions and sequential dependencies.
What you can do after
Apply task decomposition by listing work, mapping dependencies, and identifying actions suitable for concurrent execution.

Read how Learn Concurrent Programming with Go explains decomposition →

Also covered in

What to know first

Related concepts

Questions about decomposition

What is decomposition?

Decomposition is the process of dividing a complex problem, task, or system into smaller constituent parts that can be handled or analyzed separately.

Which Manning books explain decomposition?

Learn AI-Assisted Python Programming, Second Edition, Grokking Concurrency, Get Programming: Learn to code with Python, Machine Learning System Design, Functional Programming in JavaScript, Agent Design Patterns, The Art of AI Product Development, AI Agents in Action, Second Edition and 3 more.

What should I know before learning decomposition?

Manning books that teach decomposition usually introduce language model, prompt, loop and conditional logic first.

What kinds of decomposition are there?

Kinds of decomposition include multi-step decomposition, query decomposition and single-step decomposition.

What is decomposition part of?

Decomposition is part of chain-of-thought prompting. Chain-of-thought prompting is a technique that elicits or supplies intermediate reasoning steps to guide a model toward a final answer.

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.