The Thinking Room Companion

A ChatGPT app that turns questions into visible, accountable judgements. AI proposes, organises and challenges; the human decides and remains responsible. Human confirmation controls the final record.

Comment

The Thinking Room Companion

The Problem

Answers are everywhere. They arrive quickly, fluently and often with enough polish to feel finished.

Throughout the Thinking in the Age of Answers trilogy, I argue that:

Abundant answers increase rather than remove the need for human judgement.

A useful response may still be answering the wrong question. A confident answer may still rest on weak assumptions. Fluency is not evidence, and an answer is not yet a judgement.

The Thinking Room is a human-governed judgement system inside ChatGPT.

The Thinking Room Companion gives the movement from answer to judgement somewhere visible to happen. It helps people make and record judgements inside ChatGPT without surrendering responsibility for what they carry forward.

GPT-5.6 proposes. The human decides what enters the room. The human remains Chair.

What It Does

The user contributes naturally in ChatGPT. GPT-5.6, acting as Chief, interprets that contribution and proposes structured entries for a visible Thinking Room. The human, acting as Chair, reviews those proposals before anything becomes part of the accepted record.

The interaction contract is:

Contribute -> GPT-5.6 interprets provisionally -> human reviews -> accepted material enters the record -> human owns the judgement.

The Chair can accept, amend, reclassify, remove or reject proposed material. Accepted entries are organised as:

  • Evidence
  • Interpretations
  • Challenges
  • Uncertainties
  • Judgement
  • Ownership

The result is not simply another AI response. It is a persistent, human-owned Judgement Record that shows what evidence and reasoning the human was prepared to accept, what remains uncertain, and who owns the decision.

Why It Is Different

Most AI assistants present an immediate response. The Thinking Room conducts an inquiry and separates conversation from commitment.

Conventional AI assistant Thinking Room
Produces an immediate response Conducts a structured inquiry
AI interpretation is presented as the output AI interpretation remains provisional
Reasoning remains embedded in chat Reasoning becomes visibly structured
Acceptance may remain implicit Commitment requires explicit human action
The transcript is the main record A human-owned Judgement Record is the outcome

The distinction is not merely presentational. GPT-5.6 cannot directly commit its proposals to the accepted record. Human confirmation is an enforced application rule.

Rejected proposals do not enter the accepted room. AI-requested analysis remains provisional until the human chooses to retain it. Exports are generated from accepted material rather than the full conversation.

Inspiration

This was not the plan.

For more than 20 years, I have worked across performance analysis, higher education and applied learning. Much of that work has involved helping people notice what matters, examine evidence and make decisions in situations where there is no perfect answer.

Over the last year, I deliberately worked alongside AI to build practical tools, educational resources, websites and books. AI shortened the distance between an idea and something I could test. It also produced possibilities and answers faster than I could responsibly inspect them.

That experience led to a central question:

If AI can generate answers, what is the role of human judgement?

That question became the foundation of my book series, Thinking in the Age of Answers.

I discovered OpenAI Build Week through an OpenAI developer email close to the deadline. It created an unexpected opportunity to turn those ideas into a focused working application: one room, one consequential question, one visible reasoning record and one human-owned judgement.

How It Was Built

The answer was not the work.

Codex could propose code and routes through a problem, but each answer still had to be applied, run and tested against the experience I was trying to create. A successful build was evidence, not proof that the experience was right. I needed the application to make one rule unavoidable: GPT-5.6 could propose, but it could not accept its own proposal.

User contribution in ChatGPT
        |
        v
GPT-5.6 provisional interpretation
        |
        v
Visible proposal
        |
        v
Human: accept / amend / reclassify / remove / reject
        |
        v
Accepted room state
        |
        v
Human-owned Judgement Record

The application uses:

  • TypeScript and React for the application and embedded interface
  • OpenAI Apps SDK and Model Context Protocol (MCP) for the ChatGPT tools and widget connection
  • Prisma and PostgreSQL for persistent, session-separated room state
  • Zod for typed input and output validation
  • Render for the deployed MCP service
  • Vitest and Testing Library for deterministic, semantic, MCP, persistence and interface tests

The state engine separates conversation, provisional proposals and accepted room state. Proposal resolution is idempotent and protected against repeated actions, stale proposals and cross-session mutation. Markdown and PNG exports are generated from accepted room state.

The implementation developed through a repeated loop: describe the intended behaviour, build it, encounter what actually happened, and decide what the evidence justified changing next. Several features technically worked before they worked as part of a coherent room.

How Codex and GPT-5.6 Were Used

I designed the Thinking Room method, the human-confirmation boundary and the product decisions. I understood the experience I wanted to create, even when I did not yet know how to implement it in TypeScript, React, the Apps SDK or MCP.

Codex helped engineer the application. It proposed technical routes through the TypeScript state model, React widget, Apps SDK and MCP integration, Prisma persistence, proposal-integrity controls, automated tests, deployment on Render and the export workflow. I ran those routes against the product I was trying to create, reported failures and decided what needed to change. The repository history preserves that implementation and iteration.

GPT-5.6 conducts the live inquiry inside ChatGPT. Acting as Chief, it interprets contributions, consults the accepted room, surfaces distinctions and challenges, proposes structured entries and offers bounded next moves. It may reason with the room, but it cannot accept its own proposals or own the judgement.

Codex helped build the room. GPT-5.6 helps conduct it. The human remains Chair.

Why Codex Mattered

My professional life has been built around education, performance analysis, practical learning and helping people notice what matters. I could picture the experience I wanted to create. I am not a professional software engineer, and I could not have produced this application - let alone within Build Week.

Codex shortened the distance between the idea and the artefact. It gave me technical possibilities that I could inspect, test and refine across TypeScript, React, the Apps SDK, MCP, Prisma, PostgreSQL and Render. Some worked. Some failed. Some built successfully but did not create the experience I was trying to make.

This was not a process in which Codex independently built the product. I defined the requirements, evaluated the results, identified failures and made the final product decisions. When accepted entries disappeared, when Ownership failed to persist, or when the widget created a second competing conversation, the visible behaviour contradicted the intended design and the work continued.

That repeated a distinction I had already reached while writing Building the Thinking Room: “I could not yet write the code. I could still judge the experience I was trying to create."

Codex did not supply the methodology. It expanded my ability to implement it.

Build Week Contribution

Build Week turned the method into something that could be encountered rather than only described. During the event, I delivered a working ChatGPT App vertical slice with:

  • an Apps SDK widget embedded in ChatGPT;
  • a deployed MCP service;
  • persistent PostgreSQL-backed room state;
  • a complete proposal lifecycle with accept, amend, reclassify, remove and reject actions;
  • an enforced human-confirmation boundary;
  • separate Judgement and Ownership records;
  • bidirectional consultation grounded in accepted state;
  • Markdown and PNG Judgement Record exports;
  • deterministic, semantic, MCP, persistence and React interaction tests; and
  • judge installation and verification instructions.

Challenges and Learning

The first version worked technically, but it did not feel like a room.

The user could speak in ChatGPT and also type into the embedded widget. Instead of creating one coherent place for inquiry, I had created two competing conversations. I stopped and reset the interaction: conversation would happen in ChatGPT; the widget would become the place where Chief's interpretation was reviewed and either accepted into the room or refused.

That reset exposed a wider lesson. A feature could function technically and still fail in practice. An acceptance button was not enough if the accepted entry disappeared, persisted in the wrong place or left the user unsure what had happened.

Another challenge was deciding how much authority to give the AI. Too much authority risks dependence and premature confidence. Too little makes the system unhelpful. The solution became an application invariant:

The AI may propose. The human must decide.

Responsible AI could not remain a promise in the instructions. The relationship had to be visible in the interaction and protected in the code.

Potential Impact

The Thinking Room is for moments when an answer begins to carry weight.

In education, obtaining an answer is increasingly not the difficult part. The harder question is whether a student has examined it, challenged it and reached a judgement they are prepared to defend and own.

The Companion makes that movement more visible. A student evaluating a research claim can use GPT-5.6 to surface interpretations, evidence gaps and challenges. The application separates what AI has offered from what the student has deliberately accepted into their reasoning record.

The same pattern could be useful in research supervision, product review and other professional decisions where people may rely on what is carried forward.

The current prototype demonstrates the interaction model. It does not yet claim proven educational effectiveness.

What's Next

The next test is simple: put the app in front of people who did not design it.

Can they understand the difference between conversation, proposal and accepted record? Can they see what the room is asking them to do? Does it help them make their own judgement more visible?

Those questions cannot be answered by adding more claims to the project description. They need to be answered through use.

Most AI products are designed to produce answers. The Thinking Room Companion is designed to help humans decide which answers deserve confidence.

Codex helped build the room. GPT-5.6 helps conduct it. The human remains Chair.

Built With

  • ai
  • chatgpt
  • codex
  • critical-thinking
  • education
  • gpt-5.6
  • human-in-the-loop
  • thinking
Share this project:

Updates