An AI-assisted result becomes reusable only after it works without the conversation. Use a three-stage loop: capture the result and context, verify the claims and behavior, then crystallize the confirmed lesson into the smallest useful asset.
Capture enough context
Begin with the learning record:
- objective and starting state;
- constraints and policy boundary;
- attempted steps;
- result that appeared successful;
- material AI assistance;
- risks and assumptions; and
- evidence still needed.
Capture is not endorsement. It prevents important context from disappearing before review.
Verify before preserving
Choose checks that can fail:
- Reproduce the result from a known starting state.
- Inspect changed files and outputs.
- Test expected, boundary, and invalid cases.
- Compare technical claims with primary documentation.
- Remove the chat and repeat the instructions.
- Ask another person to follow them when appropriate.
Verification should match the claim. A successful command does not prove that a general explanation is correct. A passing sample does not cover all inputs.
If the result cannot be reproduced, keep it as an unresolved experiment, not a reusable workflow.
Crystallize the smallest useful form
Choose the least complex artifact that preserves the verified value:
- a note for an explanation;
- a checklist for a process requiring judgment;
- a test for expected behavior;
- a script for deterministic repetition;
- a project convention for repository-wide guidance; or
- a skill for a repeatable agent workflow that still requires interpretation.
Smaller assets are easier to inspect and maintain. Do not create automation because the conversation was long.
Test without the chat
Close the conversation. Start from the asset and its stated prerequisites. Ask:
- Can I identify the input and expected output?
- Are placeholders and permissions explicit?
- Does it state failure conditions?
- Does it preserve safety and policy boundaries?
- Can I verify the result?
- Does it identify the source or rationale?
Revise until the asset stands alone. Keep a link to the learning record for history, not as a hidden dependency.
Commit the verified asset
When the asset belongs in a Git project:
- inspect status and diff;
- exclude chat transcripts, secrets, private data, and unrelated files;
- run the documented verification;
- stage the asset and any necessary tests or documentation;
- write a commit message describing the reusable outcome; and
- record the commit in the learning record.
The commit is a checkpoint, not proof. Later evidence may require improvement.
Repeat the loop
Use failures as new input:
Capture evidence → verify cause → improve asset → test independently → commit
Do not silently rewrite history to make the first version look correct. A small maintenance record teaches which assumptions changed.
Example
An AI suggests a command to format project files. Capture the command, directory, tool version, and changed paths. Verify it on a practice copy, inspect the diff, and confirm the official option documentation. Crystallize it as a documented project script with a check mode. Run it without chat and commit the script, documentation, and test evidence as one logical change.
Common mistakes
- Crystallizing before verification.
- Treating one successful example as a stable workflow.
- Preserving the whole chat as the asset.
- Automating judgment that should remain visible.
- Omitting versions, inputs, failures, and rollback.
- Committing private prompts or course material.
Do this now
Choose one safe learning record. Identify its unverified claims, run one check that could disprove the result, and create the smallest standalone asset. Test it without reopening the conversation.
Log what you learned
Record only:
- Result: What did the action produce?
- Evidence: What observation, test, or source supports that result?
- Next action or unresolved question: What should happen next?
Next, use a decision tree to choose among a note, checklist, script, convention, skill, and automation.