agentleFS
stepaniniwisstepaniniwis/claude-skills/skills/build/abductive-bridge/SKILL.md

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".

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
  1. Distinctive:

    Every construct must have conditions under which it would NOT hold.

    line 100
  2. Distinctive:

    Remove one constituent code.

    line 149
  3. Distinctive:

    When the same data pattern supports multiple theoretical readings:

    line 163
  4. Distinctive:

    If underdetermined by data: acknowledge this honestly and state which interpretation you adopt and why (theoretical parsimony, consistency …

    line 168
  5. Distinctive:

    Every theme becomes a construct.

    line 198
  6. Distinctive:

    non-sycophant: Always active. This skill must challenge weak construct logic, not validate it.

    line 214

≈ “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.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

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

InputMode
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:

  1. Functional unity: They serve the same theoretical function (e.g., all three convert tension into resource)
  2. Temporal co-occurrence: They appear in the same biographical phase or context
  3. Conceptual complementarity: They represent different facets of the same underlying process

Three illegitimate answers (flag if present):

  1. "They feel related" — feeling is not reasoning
  2. "They appeared in the same section of the interview" — proximity is not function
  3. "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:

  1. The pattern: "Across [n] participants, we observed [specific pattern — not vague similarity but shared behavior/experience]"
  2. The surprise: "This pattern is surprising because existing theory predicts [alternative] — specifically, [Author, Year] argue that [contrary expectation]"
  3. The explanation: "We theorize [construct name] as [definition] because [reasoning]. The [n] codes that constitute it share [specific common function/property]"
  4. The alternative: "[Alternative interpretation] — e.g., that these themes simply [alternative grouping/explanation] — was considered but rejected because [evidence against alternative]"
  5. 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:

  1. State both interpretations explicitly
  2. Identify the empirical evidence that distinguishes them (if any)
  3. Identify the theoretical commitments each requires
  4. 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 writesThe real problemFix
"This construct isn't grounded in the data"Grouping logic is invisibleWrite the Step 3 reasoning chain
"How is this different from [existing concept]?"Boundary isn't establishedRun Test 4 (Literature Collision), write distinction paragraph
"You assert rather than derive"The construct appeared without analytical narrationShow the analytical steps that produced it (→ methods-narrative-architect)
"This seems like a label for your findings, not a theory"Construct is descriptive, not explanatoryIdentify the mechanism the construct captures; if none, reclassify as descriptive
"The three sub-mechanisms don't obviously belong together"Functional unity isn't statedExplicitly state the shared function (Step 2, Grouping Question)
"What would count as evidence against this?"No falsification conditionsRun 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).

Download now (ZIP)

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
What did you use it for? e.g. Reviewing pull requests in a Rails app

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.