abductive-bridge
Skill0 starsChanged 7 months agoMITView on GitHub
Builds the theoretical reasoning that connects qualitative codes/themes to abstract constructs. The hardest move in qualitative research: showing WHY these patterns become THAT construct. Solves the "data-to-theory leap" problem — when codes exist but the construct they form is asserted rather than derived. Forces explicit reasoning: why this grouping, what the shared theoretical function is, what alternatives were considered, what would falsify the construct. Works with Gioia (SOT→AD), Grounded Theory (categories→core category), Case Study (patterns→propositions), and any qualitative design requiring abductive inference. Trigger: "how do I justify this construct", "why do these themes belong together", "data-to-theory bridge", "abductive", "how do I explain the leap from codes to model", "reviewer says my constructs aren't grounded", "construct derivation".
In this repository19 other files it gives its agents.
- a-journal-architectureSkill
- citation-risk-auditorSkill
- desk-rejection-preventerSkill
- hallucination-auditSkill
- paper-revision-diagnosticSkill
- saturation-auditorSkill
- argument-architectureSkill
- methods-narrative-architectSkill
- qualitative-coderSkill
- rq-architectSkill
- theory-map-architectSkill
- theory-section-architectSkill
- anti-ai-writingSkill
- data-integrity-guardSkill
- draft-review-loopSkill
- evidence-disciplineSkill
- non-sycophantSkill
- paper-feedback-pipelineSkill
- research-lifecycleSkill
The file
We split this skill into the rules it gives an agent
6 rules. About 0 are common, 6 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈6
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 100
Every construct must have conditions under which it would NOT hold.
- Distinctive: line 149
Remove one constituent code.
- Distinctive: line 163
When the same data pattern supports multiple theoretical readings:
- Distinctive: line 168
If underdetermined by data: acknowledge this honestly and state which interpretation you adopt and why (theoretical parsimony, consistency …
- Distinctive: line 198
Every theme becomes a construct.
- Distinctive: line 214
non-sycophant: Always active. This skill must challenge weak construct logic, not validate it.
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Abductive Bridge
Makes the invisible reasoning between data patterns and theoretical constructs visible.
The Problem This Skill Solves
Qualitative researchers code data rigorously, group codes into themes, and then — in one sentence — announce a construct. The construct may be brilliant. But the reasoning that produced it is hidden. The reviewer sees a gap where the researcher sees an obvious connection.
This skill forces that reasoning into the open. It does not produce constructs (that's the researcher's job). It interrogates and narrates the logic behind constructs that already exist.
Core Principle: Abduction Is Not Induction
Induction: Data → Pattern → Generalization ("All observed X are Y, therefore all X are Y") Deduction: Theory → Hypothesis → Test ("If theory T is correct, we should observe Y") Abduction: Surprising pattern → Best explanation → Theoretical claim ("Y is surprising; the best explanation is Z; Z constitutes a new construct")
Most qualitative research claims to be inductive but is actually abductive: researchers don't just generalize from data; they construct the best theoretical explanation for patterns that existing theory doesn't predict. Making this explicit is the skill.
Mode Detection
| Input | Mode |
| Codes/themes + "how do I justify grouping these?" | → DERIVE |
| Existing construct + "is this grounded enough?" | → AUDIT |
| Two competing interpretations of the same data | → ADJUDICATE |
| "Reviewer says my construct isn't derived from data" | → REPAIR |
Mode DERIVE: Build the Bridge from Codes to Construct
Step 1: Map the Codes
List all codes/themes being grouped under the proposed construct. For each:
- What is the code? (label + definition)
- Where does it appear? (which participants, which phases/contexts)
- What is its empirical anchor? (strongest verbatim quote)
Step 2: Surface the Implicit Logic
Answer explicitly — don't let these stay in the researcher's head:
The Grouping Question: Why do THESE codes belong together and not with other codes?
Three legitimate answers:
- Functional unity: They serve the same theoretical function (e.g., all three convert tension into resource)
- Temporal co-occurrence: They appear in the same biographical phase or context
- Conceptual complementarity: They represent different facets of the same underlying process
Three illegitimate answers (flag if present):
- "They feel related" — feeling is not reasoning
- "They appeared in the same section of the interview" — proximity is not function
- "Previous literature groups them" — then you're applying, not deriving
The Naming Question: Why THIS label for the construct?
- Does the label capture the mechanism, not just the topic?
- Does it distinguish this construct from adjacent concepts in the literature?
- Would a reader who knows only the label predict roughly what the construct contains?
The Boundary Question: What is NOT part of this construct?
- Which adjacent codes were considered and excluded? Why?
- Where does this construct end and the next begin?
- What would a case look like that has this construct present vs. absent?
Step 3: The Abductive Argument
Construct the explicit reasoning chain. This becomes the paragraph that goes into the paper.
Structure:
- The pattern: "Across [n] participants, we observed [specific pattern — not vague similarity but shared behavior/experience]"
- The surprise: "This pattern is surprising because existing theory predicts [alternative] — specifically, [Author, Year] argue that [contrary expectation]"
- The explanation: "We theorize [construct name] as [definition] because [reasoning]. The [n] codes that constitute it share [specific common function/property]"
- The alternative: "[Alternative interpretation] — e.g., that these themes simply [alternative grouping/explanation] — was considered but rejected because [evidence against alternative]"
- The boundary: "[Construct name] is distinct from [adjacent construct] in that [specific differentiator]"
If the pattern is NOT surprising: Then the construct is descriptive, not theoretical. That's fine — but label it as such. Descriptive constructs catalog what exists; theoretical constructs explain why.
Step 4: Falsification Check
Every construct must have conditions under which it would NOT hold. State them.
- "If participants described [X], compensatory equilibration would be absent"
- "The construct requires [minimum condition] — participants who [counter-condition] would not display it"
This is not about actually falsifying — it's about showing the construct has empirical bite. A construct that cannot be absent in any data is not a construct; it's a tautology.
Step 5: Output
For each construct, produce:
## [Construct Name]
**Constituent codes:** [list with participant coverage]
**Grouping logic:** [functional unity / temporal co-occurrence / conceptual complementarity]
**The abductive argument:**
[The 5-element reasoning chain from Step 3]
**Adjacent constructs distinguished:**
- [Construct X] differs because [specific differentiator]
**Boundary conditions:**
- Present when: [conditions]
- Absent when: [conditions]
**Falsification:** The construct would not hold if [specific empirical condition]
**Strength assessment:** STRONG / ADEQUATE / WEAK
- Evidence breadth: [n/N participants]
- Evidence depth: [quality of quotes — do they explicitly articulate the mechanism, or only imply it?]
- Distinctiveness: [how clearly separated from adjacent constructs?]Mode AUDIT: Test an Existing Construct
Take a construct that already appears in a paper/chapter and run the following tests:
Test 1: Reverse Engineering
Can you reconstruct the grouping logic from the data alone, without knowing the construct name? If yes, the construct is well-grounded. If no, the name is doing work the data isn't.
Test 2: Substitution
Could a different construct name cover the same data equally well? If yes, the current name may not be specific enough. If multiple names work, the construct boundary is fuzzy.
Test 3: Subtraction
Remove one constituent code. Does the construct still hold? If yes for every code, the construct is too broad. If removing any single code breaks it, the construct is tight.
Test 4: Literature Collision
Does an existing construct in the literature already cover this ground? If yes, you need to argue why a new construct is necessary. If the difference is only in population or context, you're application-spotting, not constructing.
Test 5: The Hostile Reviewer Question
Formulate the single most damaging question a reviewer could ask about this construct. Then answer it. If you can't answer it, the construct needs work.
Output: Pass/Fail per test + specific revision suggestions.
Mode ADJUDICATE: Choose Between Competing Interpretations
When the same data pattern supports multiple theoretical readings:
- State both interpretations explicitly
- Identify the empirical evidence that distinguishes them (if any)
- Identify the theoretical commitments each requires
- If underdetermined by data: acknowledge this honestly and state which interpretation you adopt and why (theoretical parsimony, consistency with other findings, explanatory reach)
The honest version: "Both interpretations are consistent with our data. We adopt [X] because [reason], while acknowledging that [Y] remains a viable alternative that future research — particularly [specific design] — could adjudicate."
This is stronger than pretending certainty. Reviewers respect acknowledged underdetermination more than hidden it.
Mode REPAIR: Fix Reviewer-Flagged Construct Problems
| Reviewer writes | The real problem | Fix |
| "This construct isn't grounded in the data" | Grouping logic is invisible | Write the Step 3 reasoning chain |
| "How is this different from [existing concept]?" | Boundary isn't established | Run Test 4 (Literature Collision), write distinction paragraph |
| "You assert rather than derive" | The construct appeared without analytical narration | Show the analytical steps that produced it (→ methods-narrative-architect) |
| "This seems like a label for your findings, not a theory" | Construct is descriptive, not explanatory | Identify the mechanism the construct captures; if none, reclassify as descriptive |
| "The three sub-mechanisms don't obviously belong together" | Functional unity isn't stated | Explicitly state the shared function (Step 2, Grouping Question) |
| "What would count as evidence against this?" | No falsification conditions | Run Step 4 |
Common Anti-Patterns
The Premature Umbrella
Grouping codes under a construct before understanding what they share. The construct name comes first, the reasoning follows. Fix: start with the codes, let the shared function emerge.
The Literature Import
Using an existing construct from the literature and claiming it "emerged from the data." If you knew the construct before coding, you were coding deductively — which is fine, but call it that.
The Construct Inflation
Every theme becomes a construct. Not every pattern needs theoretical status. Some patterns are just patterns. Reserve construct language for patterns that do explanatory work.
The Mechanism Dodge
Naming a construct without specifying what it DOES. "Identity elasticity" is a label; "identity elasticity enables domain-switching without fragmentation" is a mechanism. Constructs without mechanisms are taxonomic, not theoretical.
The Missing Middle
FOCs → [gap] → AD. The second-order themes that mediate the abstraction are under-narrated. The Gioia table shows them; the prose skips them. Fix: narrate the SOT level in the findings section.
Integration with Other Skills
- qualitative-coder: Produces the codes this skill reasons about. Coder provides raw material; bridge provides theoretical reasoning.
- methods-narrative-architect: Narrates the PROCEDURE that produced the constructs. This skill narrates the REASONING that justifies them. Distinct but complementary — procedure = "we re-read all material asking X"; reasoning = "we grouped these themes because they share function Y."
- theory-section-architect: Builds the theoretical framework that constructs connect to. The bridge connects upward to theory and downward to data.
- research-examiner: Dimension 4 (Constructs & Relationships) audits what this skill builds.
- non-sycophant: Always active. This skill must challenge weak construct logic, not validate it.
Key References (Embedded Knowledge)
- Gioia et al. (2013) — Data structure as abductive reasoning made visible
- Locke (2007) "Rational and Intuitive Logics of Theory Development" AMR — How abduction works in management research
- Mantere & Ketokivi (2013) "Reasoning in Organization Science" AMR — Three logics of reasoning in organizational scholarship
- Van Maanen, Sørensen & Mitchell (2007) "The Interplay Between Theory and Method" AMR — Theory-method dialogue
- Shepherd & Suddaby (2017) "Theory Building" AMR — Construct clarity standards
Sprache folgt dem Input (Deutsch / English).
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

