Argument X-Ray

An educational tool that helps learners inspect, contest, and take responsibility for AI-generated formal models—before coherence is mistaken for conceptual adequacy.

Comment

Inspiration

Generative AI does not only shape what learners produce. It can also reshape the coordinate system through which they think.

I am an education researcher and philosopher rather than a software engineer. While using generative AI to explore philosophical and social-scientific arguments, I discovered that it could rapidly translate qualitative ideas into variables, directed relationships, matrices, and formal models. This opened intellectual territory that had previously felt inaccessible to me—but it also exposed a deeper educational problem.

A formal representation can be mathematically coherent, visually elegant, and still conceptually inadequate. It may silently turn interpretation into causation, treat dependent concepts as independent variables, compress historical or ethical meaning, or make one contested reading appear inevitable. Once that representation becomes part of a learner’s own intellectual coordinate system, questioning it becomes harder than simply rejecting an answer.

Argument X-Ray began with one question:

How can learners use AI to enter formal reasoning without outsourcing the judgement required to justify, revise, or refuse the resulting model?

What it does

Argument X-Ray is an educational prototype for auditing the transition from a qualitative argument to a formal relationship model.

It does not ask AI to become more authoritative. It redesigns the point at which authority is granted.

Its current working vertical slice uses one canonical educational-research argument about structured peer feedback, psychological safety, conceptual revision, and defensive compliance. The limited case allows the complete accountability mechanism to be inspected without pretending that broad coverage is evidence of reliability.

The learner is invited to:

  1. inspect a provisional suitability recommendation;
  2. examine concepts, variables, typed relationships, source spans, assumptions, compressions, and boundaries;
  3. distinguish mechanical quotation presence from semantic support;
  4. contest whether the argument should be formalised at all;
  5. accept, reject, or revise two consequential modelling decisions;
  6. see those decisions produce a new, explicit model version rather than remain as cosmetic feedback;
  7. predict the structural consequences of removing a relationship before the deterministic result is revealed; and
  8. receive an evidence-bounded responsibility report.

The report records what the learner actually decided and predicted. It does not infer general understanding, competence, conceptual adequacy, or readiness for public use from confidence, fluency, verbosity, or agreement.

Understand the model before you own the result.

How I built it

I built Argument X-Ray in close collaboration with Codex using GPT-5.6.

The development process mirrored the accountability structure of the product. I separated conceptual review from implementation: the reviewing context preserved the educational purpose, non-negotiable boundaries, and acceptance criteria, while Codex implementation tasks proposed architectures, built vertical slices, ran tests, and performed browser walkthroughs. Implementation results were returned for review before being frozen.

This loop changed the product materially. When learner decisions existed only as logs, they were rebuilt to produce active model versions. When quotation occurrence risked being mistaken for semantic support, the two states were separated. When a model with an isolated variable was described as “complete,” the language was revised to the narrower claim that it was structurally operable for one challenge. Shortcuts and silent scope reductions were therefore not treated as completed work simply because the application ran.

I did not hand-write the application code. Codex accelerated implementation, testing, debugging, documentation, and deployment. The educational purpose, conceptual boundaries, contested interpretations, acceptance criteria, and final decisions remained my responsibility.

The application is written in Python and Streamlit. Pydantic models define the audit package, learner decisions, model versions, semantic-role bindings, challenge evidence, and responsibility report. A deterministic graph engine computes structural consequences independently of the generated analysis.

The project uses a repository-scoped Codex Skill to generate a structured audit artifact. The Skill reads the fixed argument, intended use, educational contract, and shared schema, then exports a versioned JSON artifact through a deterministic local validator.

The deployed judge path does not require an API key or a live model request. Instead, Streamlit imports the previously generated Codex artifact through a fixed validation sequence:

file safety
→ envelope schema
→ version and input digest
→ outcome discrimination
→ suitability admission
→ semantic-role contract
→ local quotation verification
→ session creation

This separation is deliberate: Codex generates a provisional proposal, while the application requires the learner to audit it before accepting responsibility for the model.

Challenges I ran into

The hardest problem was not generating a model. It was preventing a generated model from acquiring more authority than the available evidence justified.

A quotation can occur verbatim in the source without supporting the formal role assigned to it. A valid JSON object can satisfy a schema while still encoding a conceptually weak interpretation. A learner can click “reject” without changing anything downstream. A correct graph prediction can demonstrate local structural reasoning without demonstrating full understanding of the original argument.

Each of these required a different boundary.

I separated mechanical quotation verification from semantic status. Learner decisions create explicit model versions with computable effects. Rejected relationships can become inactive without disappearing from the audit history. Commit-before-reveal prevents the challenge result from being copied after disclosure. Responsibility reports cite only recorded evidence IDs and explicitly state what cannot be concluded.

Another challenge was distinguishing structural operability from conceptual completeness. A model may remain usable for a narrow graph challenge even when an important variable has no active relationship or when the source’s competing outcome—defensive compliance—has not been represented as a node. The product makes that limitation visible rather than calling the model simply “complete.”

Accomplishments I am proud of

I am proud that the project provides a complete, testable accountability loop rather than a polished AI summary.

The current implementation includes:

  • a repository-scoped Codex Skill;
  • a versioned and digest-verified Codex-export artifact;
  • strict import and provenance boundaries;
  • learner decisions with explicit model effects and model versions;
  • positive, negative, and blocked challenge paths;
  • deterministic graph verification;
  • evidence-bounded responsibility reports;
  • a public judge flow requiring no credentials or API key; and
  • an automated test suite covering the central technical and epistemic boundaries.

The project was built by an education researcher and philosopher who did not hand-write the application code. Codex accelerated implementation, testing, debugging, documentation, and deployment, while the educational purpose, conceptual boundaries, contested interpretations, and final decisions remained my responsibility.

What I learned

I learned that responsible AI education requires more than displaying uncertainty or asking learners whether they agree.

Intellectual agency becomes observable only when a learner’s judgement has consequences: a definition changes, a relationship becomes inactive, an alternative remains unadopted, a challenge is blocked, or a report limits its own conclusion.

I also learned that provenance has layers. Codex can generate an artifact; a digest can reveal whether it later changed; local code can verify whether quoted text occurs in a source. None of these operations independently establishes that a semantic interpretation is adequate.

Most importantly, I learned that refusing premature formalisation is not a failure state. Sometimes the most responsible output is not a better equation, but a clearer account of why the current argument should not yet become one.

What's next for Argument X-Ray

The current MVP deliberately prioritises one inspectable case over unsupported breadth.

Future work would introduce a discriminated suitability contract for arbitrary arguments, generalise the internal engine through semantic roles, and add cases in which formalisation should proceed, require more context, or be refused.

I would also explore models with explicit competing outcomes, richer contextual boundaries, and longitudinal evidence of whether learners can later explain and defend the formal representations they chose to use.

The goal is not to make every argument mathematical.

The goal is to help learners recognise what becomes their responsibility when AI helps make an argument look mathematical.

Built With

Share this project:

Updates