constant-comparison

name	constant-comparison
description	Use when conducting the constant comparative method — comparing incidents to incidents, incidents to concepts, and concepts to concepts.

Constant Comparative Method

The constant comparative method is the engine of classic grounded theory. It converts raw experience into concepts and concepts into theory by systematic comparison. Without comparison, coding collapses into summary; with comparison, coding becomes analytic.

Use this skill whenever you are generating codes, merging categories, defining properties/dimensions, testing a core category, or evaluating saturation claims.

---

What constant comparison accomplishes

• Refines codes (definitions, inclusion/exclusion boundaries).
• Surfaces properties and dimensions of categories.
• Suggests hypotheses about conditions, strategies, and consequences.
• Prevents forcing by continually confronting ideas with new and deviant data.

---

Four stages (Glaser & Strauss, 1967) and how they operate today

Classic texts describe comparing as progressing through comparing incidents applicable to each category, integrating categories and their properties, delimiting the theory, and writing theory. In practice, these overlap—but the sequence is still pedagogically useful.

Stage 1 — Compare incidents to incidents (within emerging codes)

Goal: Ensure a code is conceptually consistent and data-grounded.

Micro-procedure:

1. Pick a code (e.g., delaying disclosure).
2. Collect several incidents tagged with that code.
3. Ask: What is similar? What differs?
4. Update the code definition; split into two codes if differences are systematic.

Output: tighter definitions; early properties (“kinds of delaying,” “degrees of delaying”).

Stage 2 — Compare incidents to concepts (refinement)

Goal: Use new data to test the conceptual label.

Micro-procedure:

1. Read a new incident.
2. Ask: “Is it still this category, or a variant, or a different category?”
3. If it stretches the definition uncomfortably, rename/split rather than “make it fit.”

Output: dimensional thinking; boundary conditions; negative cases queued.

Stage 3 — Compare concepts to concepts (integration)

Goal: Build relationship statements among categories.

Micro-procedure:

1. Take two mature categories (e.g., psychological safety and disclosure timing).
2. Ask: Do they co-occur? Does one enable/constrain the other? Under what conditions?
3. Write a memo hypothesis and mark it as provisional.

Output: contingent hypotheses; later fodder for theoretical coding.

Stage 4 — Delimiting comparisons (selective phase)

Goal: Stop expanding sideways; deepen core-related comparisons.

Micro-procedure:

1. Hold the core category constant.
2. Compare new incidents for what they add to core-linked hypotheses.
3. Drop comparisons that do not change your integrated outline.

Output: theoretical density without endless sprawl.

---

Comparison at each level (cheat sheet)

Level	Question	Typical yield
Incident ↔ incident	“Same meaning?”	Code splits/merges
Incident ↔ concept	“Still fits?”	Property/dimension refinement
Concept ↔ concept	“How connected?”	Hypotheses + theoretical codes
Model ↔ negative case	“Where breaks?”	Boundary conditions

---

Practical techniques you can use in a coding session

1) Flip-flop comparison

Take two incidents that look opposite. Force yourself to name the conceptual axis that distinguishes them (a dimension).

2) Worst-case / best-case contrast

Select extremes within your sample (if available). Ask what conditions produce the difference.

3) Silent-voice comparison

Ask: “Who is not represented here?” Negative cases may be data absences—note as a sampling issue, not only analytic failure.

4) Source triangulation comparison

Compare interview claims to observation or documents where possible. Treat discrepancies as analytic gold.

5) Time-slice comparison

Compare early vs late interview moments within a longitudinal account (if applicable).

---

Comparison matrices (lightweight templates)

Matrix A — Property discovery

Category: ________
Incident ID | Evidence snippet | Candidate property | Notes |

Matrix B — Hypothesis testing

Hypothesis: If [condition], then [strategy], leading to [outcome].
Supporting incidents (IDs):
Contradicting incidents (IDs):
Revised hypothesis:

Matrix C — Merge/split decisions

Code A vs Code B:
Similarities:
Systematic differences:
Decision: merge / split / keep separate
Rationale (comparative evidence):

---

Output format (session deliverables)

End each analytic session with:

Comparisons executed (brief list):
Code changes (rename/split/merge):
New/updated hypotheses (bullets):
Negative cases discovered:
Next comparison targets (specific incidents/sources):

This becomes part of your audit trail.

---

Common failure modes

• Coding without comparing → pretty labels, weak theory.
• Comparing only supportive incidents → confirmation bias.
• Over-merging too early → lost variation; under-merging → synonym sprawl.
• Comparing quotes instead of concepts → stays descriptive.
• Stopping comparison when the story “feels done” instead of checking saturation criteria.

---

Relationship to memoing and sampling

• Memos store the results of comparisons as hypotheses.
• Theoretical sampling targets the next comparisons you need but cannot yet make.

---

Key references

• Glaser, B. G., & Strauss, A. L. (1967). The discovery of grounded theory. Aldine.
• Glaser, B. G. (1992). Basics of grounded theory analysis. Sociology Press.
• Glaser, B. G. (1978). Theoretical sensitivity. Sociology Press.

---

Companion skills

• open-coding, selective-coding, memo-writing
• theoretical-sampling, theoretical-saturation
• glaserian-grounded-theory