The Limits of Framework Thinking: When Models Clarify and When They Distort

Last Updated June 9, 2026

Frameworks help people organize complexity, but they are not complexity itself. A framework can clarify a problem, reveal structure, guide judgment, support learning, and make knowledge easier to reuse. It can also oversimplify, overfit, exclude context, hide values, create false confidence, and make a living problem look more stable than it is.

The Limits of Framework Thinking examines what frameworks can and cannot do. It explains why structured models should be treated as lenses, not reality; tools, not truth; scaffolds, not substitutes for judgment. The article focuses on oversimplification, false precision, category errors, model lock-in, template dependence, hidden assumptions, evidence distortion, power, context loss, and governance. It argues that framework thinking is most useful when paired with humility, revision, evidence discipline, and awareness of what the framework leaves outside the frame.

This article explains how frameworks can fail when they are treated as universal answers rather than situated tools. It examines framework overuse, misplaced confidence, rigid templates, misleading diagrams, hidden values, weak evidence, audience overload, and governance gaps. It also includes computational workflows for auditing framework risk, including oversimplification risk, false precision risk, context loss, evidence weakness, audience burden, assumption opacity, governance maturity, and review priority.

Why Framework Limits Matter

Framework limits matter because frameworks are persuasive. A clean model can make an uncertain issue feel settled. A simple diagram can make a complex system feel controllable. A scoring matrix can make value judgments feel objective. A template can make weak analysis feel complete. A familiar framework can make people stop asking whether the model fits the problem.

The value of a framework comes from selection. It highlights some features while leaving others out. That is why frameworks are useful. It is also why they are risky. What a framework excludes may be as important as what it includes.

Limit-aware framework thinking does not reject frameworks. It uses them more carefully. It asks what the framework clarifies, what it simplifies, what it hides, what assumptions it carries, where it may fail, and when it should be revised, combined, or abandoned.

The limits of frameworks are not side issues. They are part of responsible framework design.

Back to top ↑

What Framework Thinking Is

Framework thinking is the use of structured models to organize attention, reasoning, explanation, comparison, communication, learning, and decision-making. It can be analytical, educational, strategic, editorial, civic, institutional, or computational. It helps people decide what to look for, how to organize what they find, and how to communicate relationships between ideas.

Framework thinking becomes dangerous when the model is treated as reality itself. A framework is a representation. It is shaped by purpose, audience, evidence, assumptions, values, and context. It is not neutral simply because it is structured.

Framework thinking is most useful when it is paired with evidence, judgment, interpretation, feedback, and revision.

Back to top ↑

Frameworks as Lenses, Not Reality

A framework is a lens. It changes what becomes visible. A systems framework highlights feedback, dependencies, delays, and leverage points. A decision framework highlights options, criteria, risk, and tradeoffs. A communication framework highlights audience, message, sequence, and response. A public reasoning framework highlights evidence, values, participation, and accountability.

Because frameworks are lenses, no single framework should be treated as the whole picture. Different lenses reveal different structures. The question is not whether a framework is “true” in isolation. The better question is whether it is useful for the purpose, context, audience, and evidence at hand.

A good framework user asks what the lens reveals and what it distorts.

Back to top ↑

Oversimplification and Reduction

Oversimplification is the most common limit of framework thinking. Frameworks simplify by design. They reduce a messy situation into parts, steps, boxes, stages, variables, criteria, or relationships. This reduction can be helpful when the goal is orientation, explanation, teaching, or comparison. It becomes harmful when the simplified version replaces the original complexity.

A framework may reduce a public problem to audience segments, a systems problem to a linear funnel, a moral problem to a cost-benefit table, or a learning problem to a content checklist. Each simplification may make the issue easier to handle, but also easier to misunderstand.

Simplification is not the problem. Unacknowledged simplification is the problem.

Back to top ↑

False Precision and Scoring Illusions

Frameworks often use scores, rankings, matrices, quadrants, maturity levels, and weighted criteria. These tools can help teams compare options and identify patterns. But they can also create false precision. A number may look objective even when it depends on subjective criteria, uncertain evidence, incomplete data, or hidden value judgments.

False precision is especially risky in strategy, public policy, sustainability, risk communication, decision science, and content governance. A score can be useful, but it should not make contested judgment disappear. The question is not only “What is the score?” but “Who chose the criteria, what evidence supports the score, what uncertainty remains, and what values are embedded in the weighting?”

Scores should support reasoning. They should not replace reasoning.

Back to top ↑

Category Errors and Level Confusion

Framework thinking can fail when a model designed for one level of analysis is applied to another. An individual-behavior model may be used to explain structural inequality. A marketing funnel may be used to explain civic deliberation. A strategic positioning framework may be used to explain scientific uncertainty. A metric framework may be used to settle ethical disagreement.

These are category errors. They happen when the framework is not wrong in itself, but wrong for the level or purpose. A model can be useful in one context and misleading in another.

Before using a framework, ask what level of analysis it was built for and what level the problem actually requires.

Back to top ↑

Template Dependence and Formulaic Thinking

Templates help knowledge scale. They make articles, reports, repositories, metadata, and review workflows more consistent. But templates can also weaken thinking when users fill boxes instead of examining the problem. A template can create the appearance of completeness while leaving important questions unanswered.

Formulaic framework use often appears in content systems. An article has a table, a method section, a code block, a reference section, and a footer, but the structure does not match the topic. The page looks complete, yet the thinking is thin. This is template dependence: the form becomes stronger than the reasoning.

A template should serve thinking. Thinking should not serve the template.

Back to top ↑

Model Lock-In and Conceptual Inertia

Model lock-in occurs when a framework becomes so familiar that it prevents people from seeing alternatives. A team may keep using the same matrix, funnel, map, scorecard, or process because it is established, not because it fits the problem. Over time, the framework becomes part of institutional habit.

Conceptual inertia is especially common in organizations and knowledge systems. A taxonomy created early becomes difficult to change. A content template becomes the default even when the series changes. A strategic model continues to shape decisions after the environment shifts. A governance process remains in place after it stops helping.

Frameworks should be easy to revise, replace, or retire when they stop helping.

Back to top ↑

Hidden Values, Power, and Framing

Frameworks carry values. They decide what counts as evidence, what categories exist, what criteria matter, what relationships are visible, what tradeoffs are acceptable, and whose perspective is centered. These choices may be explicit or hidden. Hidden values are especially risky because they can make a framework appear neutral while it quietly prioritizes certain interests.

Power also shapes framework design. The person or institution that defines the framework often defines the problem. They decide who is included, what options are considered, what outcomes are measured, and what forms of knowledge are legitimate. A framework can support public reasoning, but it can also narrow the space of public reasoning.

A responsible framework makes its values and power relations visible enough to be questioned.

Back to top ↑

Evidence, Uncertainty, and Overclaiming

Frameworks can make evidence easier to organize, but they can also make weak evidence appear stronger than it is. A model may connect claims, sources, and conclusions in a clean structure, but the underlying evidence may be incomplete, contested, outdated, or context-specific. The structure does not validate the evidence.

Frameworks can also flatten uncertainty. A diagram may show relationships without indicating confidence. A table may compare options without showing evidence quality. A score may summarize risk without showing disagreement. A framework may present a theory of change without testing whether the causal chain holds.

A framework should make uncertainty easier to see, not easier to hide.

Back to top ↑

Context Loss and Transfer Failure

Frameworks often travel from one context to another. A model designed for business strategy may be used in public policy. A learning scaffold may be used in technical documentation. A communication model may be used in sustainability reporting. Transfer can be useful, but it can also fail when context is stripped away.

Context loss occurs when a framework is reused without its assumptions, limitations, domain conditions, evidence base, or audience constraints. A framework that worked in one setting may become misleading in another. The more portable a framework becomes, the more important its context notes become.

Reusable frameworks need context preservation, not just clean packaging.

Back to top ↑

Audience Burden and Framework Fatigue

Frameworks can overload audiences. A reader may face a table, a diagram, a matrix, a model, a workflow, a glossary, and a code example in the same article. Each element may be useful, but the combined burden can make the content harder to use.

Framework fatigue occurs when audiences encounter too many models without clear purpose or sequence. They may begin to see frameworks as decorative complexity rather than useful structure. This is a design failure. The framework should reduce cognitive load, not add to it.

A framework that makes the author feel organized but makes the reader feel lost has failed its purpose.

Back to top ↑

When Not to Use a Framework

Not every explanation needs a framework. Sometimes a plain answer is better. Sometimes a story is better. Sometimes a direct comparison is enough. Sometimes the evidence is too uncertain for a structured model. Sometimes the issue is too contested for a neat diagram. Sometimes the framework would create more authority than the underlying knowledge deserves.

Knowing when not to use a framework is part of framework literacy. A framework should be used when it clarifies relationships, supports judgment, improves navigation, or makes maintenance easier. It should not be used merely because it looks organized.

The best framework designers are willing to leave a framework out.

Back to top ↑

Governance for Framework Limits

Framework limits need governance because weaknesses appear over time. A model that was useful at publication may become stale. A taxonomy may drift. A scoring system may stop matching the decision. A template may become too rigid. A framework may be reused in contexts where it no longer fits.

Governance should track assumptions, evidence status, review dates, context notes, owner, reuse status, dependency links, audience burden, and retirement conditions. It should also include a way to flag frameworks that are being overused or misused.

Framework governance should make it easier to revise or remove a model, not only easier to publish it.

Back to top ↑

Practical Uses of Limit-Aware Framework Thinking

Limit-aware framework thinking can improve article design, strategic planning, public communication, policy explanation, science communication, educational scaffolding, content governance, and repository design. It helps teams use frameworks without turning them into rigid formulas or false authority.

Limit-aware framework thinking makes frameworks more useful by making them less absolute.

Back to top ↑

Relationship to Framework Composition, Scaling Knowledge, Systems Explanation, and Public Reasoning

The limits of framework thinking connect directly to framework composition, scaling knowledge, systems explanation, public reasoning, evidence architecture, and content governance. Each of these practices depends on frameworks, but each can also fail when frameworks are overused, misapplied, or left ungoverned.

Every framework in a knowledge system should have both a use case and a limits case.

Back to top ↑

How Limits Thinking Supports Content Frameworks

Limits thinking supports content frameworks by preventing structure from becoming dogma. A content system can use article maps, templates, taxonomies, metadata, repositories, internal links, and governance queues without pretending that those structures are complete or permanent. Limits thinking keeps the system open to revision.

In a Content Catalyst-style knowledge system, limits thinking can be expressed through metadata, review notes, source status, “when not to use” sections, examples of misuse, model-fit scores, context boundaries, and retirement rules. These elements help readers and editors understand where a framework applies and where it should be questioned.

A mature content framework does not only explain how to use a model. It explains how the model can fail.

Back to top ↑

Ethics, Humility, and Responsible Framework Use

Responsible framework use requires humility. A framework should not pretend to resolve what remains uncertain, contested, political, ethical, or context-dependent. It should help people reason more clearly while preserving the conditions for challenge, revision, and disagreement.

Ethical framework use also requires attention to power. Who defines the model? Whose knowledge counts? Who benefits from the categories? Who is burdened by the simplification? Who can contest the framework? Who maintains it? A framework without accountability can become a quiet form of authority.

• Humility: Treat frameworks as partial representations.
• Transparency: State assumptions, boundaries, and evidence limits.
• Plurality: Allow more than one lens where the problem requires it.
• Context: Preserve the conditions under which a framework applies.
• Evidence discipline: Connect claims to sources, confidence, and uncertainty.
• Value visibility: Name criteria, tradeoffs, and priorities.
• Power awareness: Identify who designs, uses, and benefits from the model.
• Governance: Make revision, retirement, and correction possible.

Ethical framework thinking does not make frameworks weaker. It makes them more trustworthy.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

Framework limits can be supported by computational audits that score oversimplification risk, false precision risk, context preservation, evidence strength, assumption transparency, audience burden, power visibility, governance maturity, and reuse risk. These scores do not prove that a framework is good or bad. They identify where editorial, analytical, or public review is needed.

A framework usefulness score can combine clarity with humility:

A distortion risk score can combine oversimplification, false precision, context loss, audience burden, and power opacity:

A review priority score can combine low usefulness and high distortion risk:

Computational audits should help people question frameworks, not make frameworks appear more certain than they are.

Back to top ↑

Python Workflow: Framework Limits Audit

The Python workflow below evaluates framework risk by framework fit, clarity, evidence alignment, assumption transparency, governance readiness, oversimplification risk, false precision risk, context loss, audience burden, value opacity, and review status. The companion repository version extends this into a Catalyst Canvas-ready module with schemas, package-style Python, tests, JSON exports, Canvas cards, shared contracts, and governance queues.

# framework_limits_audit.py
# Dependency-light workflow for auditing the limits of framework thinking.

from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
import csv
from statistics import mean

ARTICLE_ROOT = Path(__file__).resolve().parents[1]
TABLES = ARTICLE_ROOT / "outputs" / "tables"


@dataclass
class FrameworkLimitItem:
    item: str
    framework_type: str
    description: str
    clarity: float
    fit: float
    evidence_alignment: float
    assumption_transparency: float
    governance_readiness: float
    oversimplification_risk: float
    false_precision_risk: float
    context_loss: float
    audience_burden: float
    value_opacity: float
    owner: str
    status: str

    def usefulness_score(self) -> float:
        return mean([
            self.clarity,
            self.fit,
            self.evidence_alignment,
            self.assumption_transparency,
            self.governance_readiness,
        ])

    def distortion_risk(self) -> float:
        return min(
            1.0,
            self.oversimplification_risk * 0.22
            + self.false_precision_risk * 0.22
            + self.context_loss * 0.20
            + self.audience_burden * 0.18
            + self.value_opacity * 0.18,
        )

    def review_priority_score(self) -> float:
        return min(
            1.0,
            (1 - self.usefulness_score()) * 0.50
            + self.distortion_risk() * 0.50,
        )

    def review_priority(self) -> str:
        if self.status == "revise" or self.review_priority_score() >= 0.45:
            return "high"
        if self.status == "review" or self.distortion_risk() >= 0.40:
            return "medium"
        return "standard"


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        raise ValueError(f"No rows to write: {path}")
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)


def main() -> None:
    items = [
        FrameworkLimitItem("Decision scoring matrix", "decision framework", "Useful comparison tool but may imply false precision if criteria and weights are hidden.", 0.78, 0.72, 0.70, 0.62, 0.68, 0.42, 0.72, 0.38, 0.44, 0.58, "decision", "review"),
        FrameworkLimitItem("Systems explanation map", "systems framework", "Clarifies feedback and dependencies but needs agency responsibility and boundary notes.", 0.82, 0.78, 0.74, 0.70, 0.72, 0.34, 0.24, 0.40, 0.42, 0.38, "systems", "active"),
        FrameworkLimitItem("Article template", "content framework", "Improves consistency but may become formulaic when used without section judgment.", 0.80, 0.76, 0.68, 0.66, 0.70, 0.52, 0.26, 0.46, 0.36, 0.34, "editorial", "active"),
        FrameworkLimitItem("Legacy quadrant model", "conceptual model", "Older model has weak context notes high category compression and little evidence alignment.", 0.56, 0.44, 0.38, 0.32, 0.30, 0.76, 0.64, 0.70, 0.58, 0.62, "governance", "revise"),
        FrameworkLimitItem("Public reasoning framework", "civic framework", "Supports claims evidence values tradeoffs and accountability when participation limits are explicit.", 0.84, 0.82, 0.78, 0.76, 0.74, 0.30, 0.24, 0.34, 0.40, 0.28, "public", "active"),
    ]

    rows = []

    for item in items:
        rows.append({
            "item": item.item,
            "framework_type": item.framework_type,
            "description": item.description,
            "clarity": item.clarity,
            "fit": item.fit,
            "evidence_alignment": item.evidence_alignment,
            "assumption_transparency": item.assumption_transparency,
            "governance_readiness": item.governance_readiness,
            "oversimplification_risk": item.oversimplification_risk,
            "false_precision_risk": item.false_precision_risk,
            "context_loss": item.context_loss,
            "audience_burden": item.audience_burden,
            "value_opacity": item.value_opacity,
            "usefulness_score": round(item.usefulness_score(), 3),
            "distortion_risk": round(item.distortion_risk(), 3),
            "review_priority_score": round(item.review_priority_score(), 3),
            "owner": item.owner,
            "status": item.status,
            "review_priority": item.review_priority(),
        })

    rows = sorted(rows, key=lambda row: row["review_priority_score"], reverse=True)
    write_csv(TABLES / "framework_limits_audit.csv", rows)

    governance_queue = [
        row for row in rows
        if row["review_priority"] != "standard"
    ]

    write_csv(TABLES / "framework_limits_governance_queue.csv", governance_queue)

    print("Framework limits audit complete.")


if __name__ == "__main__":
    main()

This workflow helps identify frameworks that are useful but risky, especially where false precision, weak evidence, assumption opacity, context loss, or model lock-in may distort judgment.

Back to top ↑

R Workflow: Framework Limits Diagnostics

The R workflow below creates a framework limits dataset, calculates usefulness score, distortion risk, review priority score, and review status, then exports summary tables and base R plots. It is intentionally portable and uses only base R.

# framework_limits_report.R
# Base R workflow for auditing the limits of framework thinking.

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

setwd(article_root)

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")

if (!dir.exists(tables_dir)) {
  dir.create(tables_dir, recursive = TRUE)
}

if (!dir.exists(figures_dir)) {
  dir.create(figures_dir, recursive = TRUE)
}

items <- data.frame(
  item = c(
    "Decision scoring matrix",
    "Systems explanation map",
    "Article template",
    "Legacy quadrant model",
    "Public reasoning framework"
  ),
  framework_type = c(
    "decision framework",
    "systems framework",
    "content framework",
    "conceptual model",
    "civic framework"
  ),
  clarity = c(0.78, 0.82, 0.80, 0.56, 0.84),
  fit = c(0.72, 0.78, 0.76, 0.44, 0.82),
  evidence_alignment = c(0.70, 0.74, 0.68, 0.38, 0.78),
  assumption_transparency = c(0.62, 0.70, 0.66, 0.32, 0.76),
  governance_readiness = c(0.68, 0.72, 0.70, 0.30, 0.74),
  oversimplification_risk = c(0.42, 0.34, 0.52, 0.76, 0.30),
  false_precision_risk = c(0.72, 0.24, 0.26, 0.64, 0.24),
  context_loss = c(0.38, 0.40, 0.46, 0.70, 0.34),
  audience_burden = c(0.44, 0.42, 0.36, 0.58, 0.40),
  value_opacity = c(0.58, 0.38, 0.34, 0.62, 0.28),
  owner = c("decision", "systems", "editorial", "governance", "public"),
  status = c("review", "active", "active", "revise", "active"),
  stringsAsFactors = FALSE
)

items$usefulness_score <- rowMeans(items[, c(
  "clarity",
  "fit",
  "evidence_alignment",
  "assumption_transparency",
  "governance_readiness"
)])

items$distortion_risk <- pmin(
  1,
  items$oversimplification_risk * 0.22 +
    items$false_precision_risk * 0.22 +
    items$context_loss * 0.20 +
    items$audience_burden * 0.18 +
    items$value_opacity * 0.18
)

items$review_priority_score <- pmin(
  1,
  (1 - items$usefulness_score) * 0.50 +
    items$distortion_risk * 0.50
)

items$review_priority <- ifelse(
  items$status == "revise" | items$review_priority_score >= 0.45,
  "high",
  ifelse(
    items$status == "review" | items$distortion_risk >= 0.40,
    "medium",
    "standard"
  )
)

items <- items[order(items$review_priority_score, decreasing = TRUE), ]

write.csv(
  items,
  file.path(tables_dir, "framework_limits_summary.csv"),
  row.names = FALSE
)

governance_queue <- items[items$review_priority != "standard", ]

write.csv(
  governance_queue,
  file.path(tables_dir, "framework_limits_governance_queue.csv"),
  row.names = FALSE
)

png(file.path(figures_dir, "framework_limits_distortion_risk.png"), width = 1200, height = 700)
barplot(
  items$distortion_risk,
  names.arg = items$item,
  las = 2,
  ylab = "Distortion risk",
  main = "Framework Limits: Distortion Risk"
)
grid()
dev.off()

png(file.path(figures_dir, "framework_limits_usefulness_score.png"), width = 1000, height = 700)
barplot(
  items$usefulness_score,
  names.arg = items$item,
  las = 2,
  ylab = "Framework usefulness score",
  main = "Framework Limits: Usefulness Score"
)
grid()
dev.off()

print(items[, c("item", "framework_type", "usefulness_score", "distortion_risk", "review_priority_score", "review_priority")])

This workflow turns the limits of framework thinking into an auditable governance artifact. It helps identify where frameworks need stronger context, weaker claims, better evidence notes, clearer assumptions, or retirement review.

Back to top ↑

GitHub Repository

The companion repository for this article supports framework limits as a Catalyst Canvas-ready content-framework module. It includes framework-fit audits, evidence alignment, assumption transparency, governance readiness, oversimplification risk, false precision risk, context loss, audience burden, value opacity, distortion-risk scoring, JSON schemas, package-style Python, tests, Canvas card outputs, markdown governance queues, synthetic datasets, SQL views, documentation, and multi-language scaffolds for responsible framework governance.

articles/the-limits-of-framework-thinking/
├── canvas/
│   ├── canvas_manifest.json
│   ├── input_schema.json
│   ├── output_schema.json
│   ├── canvas_cards.json
│   └── governance_queue.json
├── html/
├── css/
├── php/
├── java/
├── python/
│   ├── framework_limits_canvas/
│   │   ├── __init__.py
│   │   ├── __main__.py
│   │   ├── cli.py
│   │   ├── models.py
│   │   ├── scoring.py
│   │   ├── validation.py
│   │   ├── governance.py
│   │   └── exporters.py
│   ├── tests/
│   │   └── test_framework_limits_canvas.py
│   └── run_framework_limits_canvas_audit.py
├── r/
│   ├── framework_limits_report.R
│   └── run_all_framework_limits_workflows.R
├── sql/
│   ├── canvas_schema.sql
│   └── canvas_queries.sql
├── docs/
├── data/
├── outputs/
│   ├── figures/
│   ├── json/
│   ├── markdown/
│   └── tables/
├── notebooks/
├── shared/
└── README.md

Back to top ↑

Back to top ↑

Back to top ↑

Why Framework Thinking Needs Limits

Framework thinking needs limits because frameworks are powerful. They shape attention, language, evidence, categories, decisions, and communication. That power can clarify complexity, but it can also distort it. A framework can make knowledge easier to scale, but it can also scale error. It can make reasoning easier to inspect, but it can also hide the values embedded in the structure.

The answer is not to abandon frameworks. The answer is to use them with discipline. A responsible framework states its purpose, scope, assumptions, evidence, limits, audience, and governance needs. It remains open to revision. It can be challenged. It can be combined with other lenses. It can be retired when it stops helping.

The strongest framework thinking is not the most framework-heavy thinking. It is the kind of thinking that knows when structure clarifies, when it distorts, and when reality must be allowed to resist the model.

Back to top ↑

Related Articles

• Scaling Knowledge Through Frameworks
• Framework Composition: How to Combine Models Without Confusion
• Content Audits and Framework Governance
• Framework Drift and Conceptual Decay
• Public Reasoning and Framework Design
• Why Content Frameworks Matter Today

Further Reading

• OECD (2017) Systems Approaches to Public Sector Challenges: Working with Change. Paris: OECD Publishing. Available at: https://www.oecd.org/en/publications/systems-approaches-to-public-sector-challenges_9789264279865-en.html
• National Academies of Sciences, Engineering, and Medicine (2017) Communicating Science Effectively: A Research Agenda. Washington, DC: The National Academies Press. Available at: https://www.nationalacademies.org/publications/23674
• Rittel, H.W.J. and Webber, M.M. (1973) ‘Dilemmas in a General Theory of Planning’, Policy Sciences, 4(2), pp. 155–169. Available at: https://urbanpolicy.net/wp-content/uploads/2012/11/Rittel%2BWebber_1973_PolicySciences4-2.pdf
• Meadows, D.H. (1999) Leverage Points: Places to Intervene in a System. The Sustainability Institute. Available at: https://donellameadows.org/archives/leverage-points-places-to-intervene-in-a-system/
• Meadows, D.H. (2008) Thinking in Systems: A Primer. White River Junction, VT: Chelsea Green Publishing.
• Simon, H.A. (1996) The Sciences of the Artificial. 3rd edn. Cambridge, MA: MIT Press.
• Kahneman, D. (2011) Thinking, Fast and Slow. New York: Farrar, Straus and Giroux.
• Gigerenzer, G. (2007) Gut Feelings: The Intelligence of the Unconscious. New York: Viking.
• Checkland, P. (1981) Systems Thinking, Systems Practice. Chichester: Wiley.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston, MA: Irwin/McGraw-Hill.
• Scott, J.C. (1998) Seeing Like a State: How Certain Schemes to Improve the Human Condition Have Failed. New Haven, CT: Yale University Press.
• Mol, A. (2002) The Body Multiple: Ontology in Medical Practice. Durham, NC: Duke University Press.
• Bowker, G.C. and Star, S.L. (1999) Sorting Things Out: Classification and Its Consequences. Cambridge, MA: MIT Press.
• Porter, T.M. (1995) Trust in Numbers: The Pursuit of Objectivity in Science and Public Life. Princeton, NJ: Princeton University Press.

References

• OECD (2017) Systems Approaches to Public Sector Challenges: Working with Change. Paris: OECD Publishing. Available at: https://www.oecd.org/en/publications/systems-approaches-to-public-sector-challenges_9789264279865-en.html
• National Academies of Sciences, Engineering, and Medicine (2017) Communicating Science Effectively: A Research Agenda. Washington, DC: The National Academies Press. Available at: https://www.nationalacademies.org/publications/23674
• Rittel, H.W.J. and Webber, M.M. (1973) ‘Dilemmas in a General Theory of Planning’, Policy Sciences, 4(2), pp. 155–169. Available at: https://urbanpolicy.net/wp-content/uploads/2012/11/Rittel%2BWebber_1973_PolicySciences4-2.pdf
• Meadows, D.H. (1999) Leverage Points: Places to Intervene in a System. The Sustainability Institute. Available at: https://donellameadows.org/archives/leverage-points-places-to-intervene-in-a-system/
• Meadows, D.H. (2008) Thinking in Systems: A Primer. White River Junction, VT: Chelsea Green Publishing.
• Simon, H.A. (1996) The Sciences of the Artificial. 3rd edn. Cambridge, MA: MIT Press.
• Kahneman, D. (2011) Thinking, Fast and Slow. New York: Farrar, Straus and Giroux.
• Gigerenzer, G. (2007) Gut Feelings: The Intelligence of the Unconscious. New York: Viking.
• Checkland, P. (1981) Systems Thinking, Systems Practice. Chichester: Wiley.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston, MA: Irwin/McGraw-Hill.
• Scott, J.C. (1998) Seeing Like a State: How Certain Schemes to Improve the Human Condition Have Failed. New Haven, CT: Yale University Press.
• Mol, A. (2002) The Body Multiple: Ontology in Medical Practice. Durham, NC: Duke University Press.
• Bowker, G.C. and Star, S.L. (1999) Sorting Things Out: Classification and Its Consequences. Cambridge, MA: MIT Press.
• Porter, T.M. (1995) Trust in Numbers: The Pursuit of Objectivity in Science and Public Life. Princeton, NJ: Princeton University Press.

Back to top ↑