Years of conversations and technical experiments had accumulated across files and tools. I could find individual passages, but I could not reliably reconstruct where an idea began, how it changed, or what evidence supported it. My current research asks how systems can preserve enough of that path for someone to inspect the reasoning, recover its evidence, and continue the work later.
The longer-term question is whether this infrastructure can help human and machine intelligence develop cumulatively.
Investigations from this program are collected under Research in Writing.
A stored file is only the beginning. A record has to keep where the information came from and how it changed, or later reconstruction is no longer possible.
Finding a relevant passage does not guarantee that enough context has been recovered. The question is whether a system can retrieve an idea in sequence, connect it to earlier evidence, and show how it developed.
Traces, validation, and explicit uncertainty should show an operator what happened, and where a conclusion is still weak.
Cognitive workspaces shape how people investigate problems with software and AI. I am exploring environments that preserve unfinished reasoning and allow a person to resume work without rebuilding the entire context.
This research also asks whether AI-assisted work develops human judgment. Producing a strong answer and developing mastery are different outcomes. The systems should leave evidence of what the person learned and how their understanding changed.
Individual memory is fragile, and a body of work has the same problem at a larger scale: surviving changes in people and tools while keeping the evidence behind its conclusions.
Corpus Engine turns exported AI conversations into a local, structured archive that can be searched and examined over time.
Its first retrieval architecture is currently being evaluated against real investigations from my own corpus. The test is practical: can the system recover enough ordered evidence to reconstruct how a question developed?
Early evaluation has already revealed an important distinction. A retrieval system can find relevant passages while still failing to recover the surrounding sequence required for interpretation. Those failures are being recorded before the retrieval architecture is revised.
The Personal Financial Research and Control System is a local-first record system built around financial transactions.
In an early ingestion run, the system loaded 71 records. A second run inserted zero duplicates. The interpretation layer classified 56 transactions and surfaced 15 as ambiguous for human review.
Those 15 transactions remained unresolved without altering the original bank records. The architecture and general findings can be public while the financial data remains private.
Thinking in Code is a developing longitudinal record of how I learned systems architecture through building.
The project uses completed investigations as source material. A reader might follow an ETL pipeline from its initial design through a structural counting failure, or watch an execution trace revise an earlier mental model of a software system.
The planned interface will let readers move through those stages visually and interact with selected mechanisms. This makes Thinking in Code an experiment in procedural learning: understanding a system through the process of investigating it.
Thinking in Code connects the two arms of this practice. The research program establishes the questions and evaluates what was learned. The studio turns selected findings into interfaces and learning experiences.
PDF Conversation ETL was my first bounded system for transforming exported conversations into structured records.
The pipeline eventually completed a full run in 493 seconds. Its diagnostic counts still contained an off-by-one mismatch between the expected input and output boundaries. The system completed its operation while violating a structural invariant.
A successful extraction now had to satisfy the record’s structural invariants before it could count as preservation.
TruthPipe tested whether uncertainty could be represented directly in a software system.
A successful provider response established that data had arrived. The evidence still required a separate evaluation before the system could classify it as confirmed, pending, stale, or erroneous.
The project showed why transport, interpretation, and truth status require separate mechanisms. That distinction now informs later systems.
This is a developing independent research program. Its present work concerns the preservation and recovery of reasoning. Its longer horizon is infrastructure through which people, software, and institutions can become more capable without losing the evidence behind what they know.