# Living Narrative Canvas Spec **The Curiosity Lab** Version: 0.1 Status: Draft interaction specification Path: `/mvp/Living-Narrative-Canvas-Spec.md` --- ## 1. Purpose This document specifies the v0.3 MVP interaction model for the **Living Narrative Canvas**. It exists to prevent another expensive implementation cycle where the concept is understood in theory but not materially expressed in the interface. The previous MVP was useful, but it exposed a failure: ```text A linear discovery path can be clear and still feel lifeless. ``` The new product direction is not to create a better linear journey. The new product direction is to create a practical, testable interface where: ```text an initial object description is expanded with meaning through exploration of motifs, themes, context, associations and structural echoes. ``` This document should be treated as the bridge between research theory and implementation. No major coding work should begin until this spec is good enough to paper-test. --- ## 2. What We Learned The first MVP helped clarify the product by failing in a useful way. The failure was not that the idea lacked value. The failure was that the interface shape was wrong. The earlier approach was: ```text theory first ideal discovery scenario linear pathway guided explanation reflection at the end ``` This produced an experience that felt: ```text dry prescribed amateurish lifeless like an educational wizard ``` The useful learning was: ```text The object narrative should stay visible. The user should explore around it. Meaning should be added back into the narrative. The narrative should become richer because of the user’s exploration. ``` The strongest current insight is: > **The initial description should be expanded with meaning through exploration of motifs and themes.** This is now the core v0.3 design hypothesis. --- ## 3. Product Decision The v0.2 linear journey should be marked as: ```text Useful research evidence. Failed experience model. Do not continue polishing. ``` The v0.3 model is: ```text Prototype v0.3 — Living Narrative Canvas ``` Core principle: > **The narrative is not the endpoint of exploration. > The narrative is the surface on which exploration happens.** --- ## 4. Goal of This Spec This spec should make the next implementation task small, concrete and testable. It should answer: ```text What does the user see? What can the user click? What changes when they click? How does the narrative grow? How do we know whether the experience is working? What should not be built yet? ``` It should prevent vague implementation prompts such as: ```text Build the Living Narrative Canvas. ``` Instead, it should support narrow implementation prompts such as: ```text Build a static Angular component with a persistent narrative, selectable anchors, an association panel, insert preview, weave action and visible updated narrative using hardcoded data only. ``` --- ## 5. Core Hypothesis > **A user will experience more curiosity and meaning when a basic object description visibly expands through explored associations than when they are led through a fixed linear explanation.** Sub-hypotheses: ```text Clickable anchors invite curiosity. Narrative inserts make meaning visible. Associations are more powerful when they explain why they exist. Themes should emerge from exploration rather than be offered as a menu. Obscure references are useful only when they increase worldness. Structural echoes are useful only when they clarify a shared pattern. ``` --- ## 6. Experience Summary The experience should begin with a simple object description: ```text A bronze sestertius of Trajan, dated 103–111 CE, shows the emperor on one side and an arched bridge over a river, probably the Danube, on the other. ``` This description remains visible. The user can select meaningful anchors: ```text bronze sestertius Trajan 103–111 CE emperor bridge Danube coin ``` Selecting an anchor reveals associations. An association explains: ```text what it is why it matters what it connects back to what theme or motif it reveals what sentence it would add to the narrative ``` The user may choose to weave the association into the narrative. The narrative then visibly expands. The resulting experience is: ```text description + explored context + motif + theme + obscure reference + structural echo + accumulated meaning ``` --- ## 7. What the Experience Is Not The Living Narrative Canvas is not: ```text a slideshow a step-by-step wizard a quiz a knowledge graph a search tool a topic menu a chatbot a CMS a personalised recommendation engine an AI-generated essay ``` It should not feel like: ```text Step 1: Observe Step 2: Learn context Step 3: Choose doorway Step 4: Reflect ``` It should feel more like: ```text Here is the object’s story. Touch a detail. See why it matters. Add that meaning back into the story. Watch the story become richer. Follow another thread. ``` --- ## 8. Minimum Viable Interface The first practical interface should have three visible areas. ### 8.1 Main Narrative Area Purpose: ```text Keep the object story visible. Show the current expanded narrative. Allow anchors to be selected. ``` Contains: ```text object title object image if available base narrative expanded narrative inserts clickable anchors or anchor chips ``` The base narrative should never disappear. When the story expands, the user should still be able to understand the original object description. ### 8.2 Association Panel Purpose: ```text Show what the selected anchor opens. Explain why the association matters. Preview how it changes the narrative. ``` Contains: ```text selected anchor available associations selected association summary relationship basis theme or motif evidence/confidence cue narrative insert preview weave action ``` Primary action: ```text Add this to the story ``` Alternative action labels: ```text Weave this in Add this meaning ``` Avoid: ```text Next Submit Continue Complete step ``` ### 8.3 Explored Meaning Area Purpose: ```text Show what has already been explored without becoming an analytics dashboard. ``` Contains: ```text explored anchors woven associations emerging themes structural echoes revealed button to view/export meaning trace ``` This area should feel light. It should not dominate the experience. --- ## 9. Core User Actions The v0.3 MVP should support these actions only: | Action | User Meaning | System Behaviour | |---|---|---| | View object narrative | “What am I looking at?” | Render base narrative and anchors | | Select anchor | “Why does this detail matter?” | Show associations for that anchor | | Select association | “What does this connection mean?” | Show summary, relationship basis and insert preview | | Weave association | “Add this meaning to the story.” | Add narrative insert to current narrative | | Revisit explored item | “What did I already open?” | Re-show association details | | View meaning trace | “How has the story grown?” | Show explored path and current narrative | | Export trace | “Keep the record.” | Export local JSON | Do not add more actions yet. --- ## 10. State Model The interface can be described with a small state model. ```text CanvasLoaded AnchorSelected AssociationSelected AssociationWoven MeaningTraceViewed MeaningTraceExported ``` ### 10.1 CanvasLoaded The user sees: ```text base narrative anchors empty association panel prompt empty explored meaning area ``` Prompt: ```text Touch a detail to see why it matters. ``` ### 10.2 AnchorSelected Trigger: ```text user selects an anchor ``` The system shows: ```text anchor label short anchor explanation if available list of associations ``` Example: ```text bridge ``` Associations: ```text Dacian campaigns Danube frontier Infrastructure as power Bridge ↔ supply chain ``` ### 10.3 AssociationSelected Trigger: ```text user selects one association ``` The system shows: ```text association label summary why it matters relationship basis theme confidence/evidence narrative insert preview ``` ### 10.4 AssociationWoven Trigger: ```text user chooses Add this to the story ``` The system: ```text adds the narrative insert to the current narrative records the association as woven reveals any new themes updates the meaning trace prevents duplicate insertion ``` ### 10.5 MeaningTraceViewed Trigger: ```text user opens meaning trace ``` The system shows: ```text base narrative current narrative explored anchors woven associations themes revealed structural echoes revealed optional final thought optional next question ``` ### 10.6 MeaningTraceExported Trigger: ```text user exports JSON ``` The system creates a local JSON file or downloadable blob. No backend. No remote storage. --- ## 11. Content Model The MVP content model should be based on: ```text object base_narrative anchors associations themes meaning_trace events ``` ### 11.1 Object ```json { "id": "object_met_08_170_120", "title": "Bronze sestertius of Trajan", "date": "103–111 CE", "medium": "Bronze", "source": "The Metropolitan Museum of Art" } ``` ### 11.2 Base Narrative ```json { "id": "base_narrative_roman_coin_trajan", "text": "A bronze sestertius of Trajan, dated 103–111 CE, shows the emperor on one side and an arched bridge over a river, probably the Danube, on the other.", "anchor_ids": [ "anchor_bronze_sestertius", "anchor_trajan", "anchor_date_103_111", "anchor_bridge", "anchor_danube", "anchor_coin" ] } ``` ### 11.3 Anchor ```json { "id": "anchor_bridge", "label": "bridge", "type": "object_detail", "association_ids": [ "assoc_dacian_campaigns", "assoc_danube_frontier", "assoc_infrastructure_as_power", "assoc_bridge_supply_chain_echo" ] } ``` ### 11.4 Association ```json { "id": "assoc_infrastructure_as_power", "label": "infrastructure as power", "association_type": "theme", "summary": "A bridge can be practical and symbolic at the same time.", "why_it_matters": "On a coin, a bridge can become a claim about movement, control and imperial capability.", "relationship_basis": "symbolic", "themes": [ "infrastructure_as_power", "movement", "authority" ], "narrative_insert": "The bridge therefore becomes more than scenery. It links military movement, engineering, public memory and the ordinary handling of money.", "connects_back_to": [ "anchor_bridge", "anchor_coin" ], "evidence_category": "Supported Interpretation", "confidence_level": "Moderate" } ``` ### 11.5 Meaning Trace ```json { "session_id": "", "object_id": "", "base_narrative_id": "", "explored_anchor_ids": [], "explored_association_ids": [], "woven_association_ids": [], "current_narrative_text": "", "themes_revealed": [], "structural_echoes_revealed": [], "optional_final_thought": "", "next_question": "", "completed_at": "", "consent_status": "accepted" } ``` --- ## 12. Association Quality Rules Every association must pass these checks before being included. ### 12.1 It Must Connect Back Bad: ```text Romans did not have tomatoes. ``` Better: ```text This coin belonged to a world both familiar and strange: money, markets and public authority existed, but ordinary Roman food lacked later staples such as tomatoes and potatoes. ``` Reason: ```text The reference increases worldness and returns to the coin’s lived context. ``` ### 12.2 It Must Change the Narrative Ask: ```text Does this association make the object story richer? ``` If not, remove it. ### 12.3 It Must Have a Relationship Basis Examples: ```text temporal spatial contextual symbolic structural analogical evidential functional ``` ### 12.4 It Must Avoid False Equivalence Bad: ```text A Roman coin is a passport. ``` Better: ```text A Roman coin shares one structure with a passport: both are small official objects that carry authority through movement. ``` ### 12.5 It Must Be Short Enough to Weave Narrative inserts should usually be: ```text 1 sentence or 1 short paragraph ``` Avoid long lectures. --- ## 13. Copy Guidelines Use language that feels alive but not dramatic. Prefer: ```text Touch a detail to see why it matters. Add this to the story. The story is beginning to gather meaning. This connection changes how the coin reads. Here is how the story has grown. What question does this leave you with? ``` Avoid: ```text Step 1 Learning objective Choose a topic Submit your reflection Complete the journey Saved narrative Educational pathway ``` --- ## 14. First Paper Test Before coding, test the interface in text. ### 14.1 Test Setup Use a simple document or slide with: ```text base narrative anchor list association list insert preview expanded narrative area ``` No Angular. No styling. No implementation. ### 14.2 Test Script Ask the tester to read: ```text A bronze sestertius of Trajan, dated 103–111 CE, shows the emperor on one side and an arched bridge over a river, probably the Danube, on the other. ``` Then offer anchors: ```text Trajan bridge Danube bronze sestertius coin 103–111 CE ``` When they choose one, show 2–4 associations. When they choose an association, show: ```text summary why it matters insert preview ``` Ask: ```text Would you add this to the story? ``` If yes, paste the insert into the narrative. Repeat 3–5 times. ### 14.3 Paper Test Questions Ask: ```text Did the story become more interesting? Did you want to click another detail? Did any connection feel surprising but meaningful? Did any connection feel random or forced? Did the expanded narrative remain coherent? What question are you left with? ``` ### 14.4 Pass Criteria The paper test passes if: ```text the user notices the narrative becoming richer the user voluntarily wants to explore at least one more anchor at least one association changes how they understand the object the user can explain why one link mattered the experience does not feel like a lesson ``` ### 14.5 Fail Criteria The paper test fails if: ```text the user treats it as a menu the narrative feels like a pile of facts the user cannot tell why links exist associations feel random the expanded narrative becomes incoherent the user waits to be told what to do next ``` --- ## 15. First Angular Slice Only after the paper test should implementation begin. The first Angular task should be deliberately small. ### 15.1 Scope Build one static component or small component group that supports: ```text base narrative clickable anchors or anchor chips association panel narrative insert preview add to story button expanded narrative explored themes list meaning trace JSON export ``` Use hardcoded data first. Do not load JSON yet. Do not add routing changes. Do not add a service unless necessary. Do not style heavily. ### 15.2 Non-Goals Do not build: ```text full app architecture Firebase backend CMS graph UI search recommendations AI generation accounts analytics dashboard complex animations ``` ### 15.3 Acceptance Criteria for First Angular Slice ```text The base narrative is always visible. The user can select an anchor. The user can select an association. The user can preview a narrative insert. The user can add the insert to the story. The story visibly updates. The association cannot be added twice. At least one theme appears after weaving. The meaning trace can be viewed or exported. ``` --- ## 16. Token-Saving Implementation Protocol To avoid another expensive but underwhelming Claude run: ### 16.1 Never Use One Large Prompt for the Whole Prototype Avoid prompts like: ```text Please build v0.3. ``` Use small prompts. ### 16.2 Use One Slice at a Time Recommended order: ```text 1. Static mock component using hardcoded Roman coin data. 2. Add insert weaving logic. 3. Add meaning trace state. 4. Add JSON export. 5. Replace hardcoded data with first-journey-roman-coin.json. 6. Add light styling. 7. Add paper-test feedback changes. ``` ### 16.3 Require Visible Output Every Claude task should produce a visible, testable change. Bad task: ```text Refactor the architecture for the Living Narrative Canvas. ``` Better task: ```text Make the base narrative remain visible while selected associations appear in a side panel. ``` ### 16.4 Stop Conditions Stop the implementation run if Claude: ```text introduces Firebase creates a CMS adds routing complexity builds a graph visualisation rewrites unrelated files creates abstract architecture without visible UI change reintroduces Next/Previous linear flow ``` --- ## 17. First Claude Implementation Prompt Use this only after the paper test. ```text You are working on The Curiosity Lab Angular prototype. Do not rebuild the whole app. Implement only the first v0.3 Living Narrative Canvas slice. Goal: Create a static Roman coin narrative canvas using hardcoded data. Requirements: - Show the base narrative permanently. - Show 5–7 selectable anchors around or within the narrative. - When an anchor is selected, show 2–4 associations. - When an association is selected, show its summary, why it matters, relationship basis, confidence and narrative insert preview. - Add an “Add this to the story” button. - When clicked, append the narrative insert to the visible narrative. - Prevent duplicate inserts. - Show explored anchors, woven associations and revealed themes. - Add a local Meaning Trace object in component state. - Add a button to export the Meaning Trace as JSON. Do not add: - Firebase - backend - CMS - graph UI - routing changes - authentication - AI-generated content - large styling system - unrelated refactors Use hardcoded data only for this task. After completion, report: - files changed - component names - how the interaction works - how to test it manually - anything deliberately not built ``` --- ## 18. Open Design Questions These should remain open until tested. ```text Should anchors be inline inside the narrative or chips below it? How many anchors should be visible at once? Should woven inserts appear chronologically or grouped by anchor? Should the user be able to remove an insert? Should structural echoes appear immediately or only after contextual associations? Should the meaning trace be visible throughout or only on request? How do we prevent the narrative becoming too long? ``` Do not solve all of these in code yet. Test first. --- ## 19. Definition of Done for This Spec This spec is useful if it allows us to: ```text paper-test the interaction without Angular give Claude a small implementation task judge whether the interface has become more alive avoid another broad expensive implementation loop keep the v0.3 prototype focused ``` --- ## 20. Provisional Conclusion The project is shifting from: ```text theory first, interface later ``` towards: ```text practical test first, theory refined by observed interaction ``` This is not a retreat from the research ambition. It is a better route to it. The Living Narrative Canvas should become a small practical test of the project’s larger claim: > **Curiosity grows when meaning becomes visible through connected exploration.**