Conversation Pattern Forge

Inspiration

Before Build Week, I had already built a forensic parser that turns an OpenAI conversation export into structured, Obsidian-ready notes. My parsed archive contains 2,004 conversations.

Preserving conversations was not enough. I knew I had developed useful ways of working with AI, yet I could not reliably find those methods again inside my own history. I wanted to move from storing conversations to understanding what recurring workflows they contained.

That became the starting point for Conversation Pattern Forge: a way to ask a focused question, review the evidence behind the answer, and turn repeated patterns into reusable workflow proposals.

My longer-term goal is to turn approved workflows into carefully reviewed skill candidates that can eventually become part of an agentic LLM Wiki and personal second-brain system.

The project was also a personal learning journey. I am not a traditional software developer, and I learned how repositories, branches, tests, and system boundaries fit together while building it. Codex helped me iterate through that complexity step by step.

What it does

Conversation Pattern Forge helps people rediscover recurring ways of working with AI based on their conversation history.

In the public demo, the user chooses one of two approved synthetic questions. The system creates one deterministic ranking of potentially relevant conversations, waits for explicit human inspection and classification, and freezes only the evidence selected for local analysis. It then derives episodes, comparable occurrences, a recurring pattern, a separate pattern assessment, and a traceable workflow candidate when the evidence is sufficient.

The workflow remains proposal only. The application does not automatically approve, install, promote, export, or execute it. Instead, it makes the evidence, uncertainties, review decisions, and provenance behind a possible reusable method visible.

How we built it

The project builds on a pre-existing Parser that converts OpenAI exports into structured notes. During Build Week, I built a deterministic, review-driven layer on top of that foundation:

• a question becomes a DiscoveryRequest and ScanSpec;
• related conversations are ranked once;
• a person explicitly inspects, classifies, and selects supporting evidence;
• a separate local-analysis approval creates a verified reviewed-Core run;
• reviewed evidence becomes Episodes and ComparableOccurrences;
• recurrence detection and assessment remain separate steps;
• a configured workflow proposal is created only when all required evidence is present.

The system retains resolvable provenance from the question and ranking through the append-only review ledger, approved evidence, pattern, assessment, and workflow proposal.

I validated the private retrieval and ranking boundary separately against my parsed archive. Private source data and results remain outside this repository. The submitted demo uses a safe synthetic Parser V1.4 pack and makes no network or provider call.

Codex was used throughout Build Week to design, implement, test, document, and iterate on the public product slice. GPT-5.6 Sol with high reasoning was the model used inside Codex during development. The demonstrated application itself is local and deterministic; its displayed data and results are not presented as GPT-5.6 runtime output.

Challenges we ran into

The hardest part was not simply finding patterns. It was making the system safe and understandable enough to trust.

I had to keep private validation separate from the public demonstration, preserve evidence and review provenance, make interrupted writes fail closed, and avoid presenting a proposal as an approved workflow. I also had to make sense of a rapidly evolving codebase while learning Git, testing, and repository workflows in real time.

There was another practical paradox: while trying to understand my conversation history, I kept creating more conversations. The problem was growing as I was trying to analyze it.

Accomplishments that we're proud of

• Building a complete public question-to-workflow demonstration on a safe synthetic Parser pack.
• Validating the private retrieval boundary without exposing private material.
• Keeping inspection, classification, selection, local evidence approval, assessment, and workflow proposal as distinct boundaries.
• Preserving inspectable evidence and deterministic lineage throughout the run.
• Producing a configured proposal-only workflow without a provider call or automatic approval.
• Learning how to design, test, and explain a complex system from scratch.

What we learned

I learned how version control works in practice: repositories, branches, worktrees, checkpoints, reviews, and how changes evolve over time.

I also learned that making something work is not enough. A useful system must make its evidence, boundaries, and uncertainties understandable.

Finally, I learned how to collaborate with AI beyond generating answers: by asking better questions, verifying claims, preserving provenance, and rebuilding understanding step by step.

What's next

• Refine the evidence and workflow-proposal experience.
• Add carefully governed Obsidian export from the existing logical note descriptors.
• Expand private validation only through separately authorized, fail-closed runs.
• Add human workflow approval before any future installation or promotion.

Built with

• Codex with GPT-5.6 Sol for development
• Python 3.11+
• Streamlit
• Pydantic
• scikit-learn and RapidFuzz
• Pytest

Testing instructions

python3.12 -m venv .venv
.venv/bin/python -m pip install -e '.[dev]'
PYTHONPATH=src .venv/bin/streamlit run \
  src/conversation_pattern_forge/ui/streamlit_app.py \
  --server.headless true

Use the default Question-reviewed workflow mode. Select Find reusable prompt drafting workflows, review and include both synthetic conversations, confirm the comparison set, then inspect the resulting Pattern and proposal-only Workflow. No credentials or provider access are required.

Built With

• codex
• gpt-5.6-sol
• pydantic
• pytest
• python
• rapidfuzz
• scikit-learn
• streamlit