Comments

• ctietze

  April 19 edited April 19

  Deep research examples

  Some technical connections

  Here's a test run dumped from Claude for deep research my zk for RAG and vector db's before I renamed the tool from zk-llm to ta, hence the weird names in the bash commands:

  ❯ deep research my zk for RAG and vector db's                                   
  
  ⏺ Skill(zk-llm-deep-research)
    ⎿  Successfully loaded skill
  
  ⏺ I'll start with a broad search to find seed notes on RAG and vector databases.
  
  ⏺ Bash(swift run zk-llm search "RAG" --depth 1 2>&1 | tail -80)
    ⎿  [0/1] Planning build
       Building for debugging...
       [0/3] Write swift-version--6CDFB4424A1E79B2.txt
       … +26 lines (ctrl+o to expand)
  
  ⏺ Bash(swift run zk-llm search "vector" --depth 1 2>&1 | tail -80)
    ⎿    snippet: "as a result. (stdin to file) Mermaid, graphviz.  LaTeX for
        vector renditions of formulae.   There could be more use cas"
         tags: []
       … +58 lines (ctrl+o to expand)
  
  ⏺ Bash(swift run zk-llm search "embedding" --depth 1 2>&1 | tail -80)
    ⎿    snippet: "Look at Backlinks[[202503100826]] and especially structure
       s embedding the note you change to make sure that  the link co"
         tags: [zettelkasten, api]
       … +60 lines (ctrl+o to expand)
  
  ⏺ Good — I've found the hub notes. Let me read the core ones and look for
    adjacent concepts like hybrid search.
  
  ⏺ Bash(swift run zk-llm show "202603280645 Zettelkasten and RAG.md"
        "202603280646 RAG Retrieval-Augmented Generation.md" "202603280655 RRF
        Reciprocal rank fusion.md" 2…)
    ⎿  Building for debugging...
       [0/3] Write swift-version--6CDFB4424A1E79B2.txt
       Build of product 'zk-llm' complete! (0.13s)
       … +90 lines (ctrl+o to expand)
  
  ⏺ Bash(swift run zk-llm tag rag --depth 2 2>&1 | tail -60)
    ⎿  Building for debugging...
       [0/3] Write swift-version--6CDFB4424A1E79B2.txt
       Build of product 'zk-llm' complete! (0.12s)
       … +26 lines (ctrl+o to expand)
  
  ⏺ Let me quickly check the BM25 and tf-idf notes since they're referenced often.
  
  ⏺ Bash(swift run zk-llm show "202412071858 Search ranking with tf-idf  term
        frequency -- inverse document frequency.md" "202412071908 BM25 search
        ranking.md" 2>&1 | ta…)
    ⎿  Building for debugging...
       [0/3] Write swift-version--6CDFB4424A1E79B2.txt
       Build of product 'zk-llm' complete! (0.12s)
       … +34 lines (ctrl+o to expand)
  
  ⏺ I have enough to synthesize. No standalone "vector database" note — your
    thinking treats vectors as one retrieval mechanism among several.
  
    Your thinking on RAG and vector databases
  
    The cluster is small and intentional — five notes, written mostly in late 2024
     and March 2026, that frame RAG as an architectural pattern and vector search
    as one pluggable retrieval option inside it rather than the defining feature.
    Three themes:
  
    1. RAG as a three-stage architecture, with retrieval as the pluggable middle.
    - 202603280646 RAG Retrieval-Augmented Generation.md — defines the indexing →
    retrieval → generation pipeline, and explicitly separates the mechanism from
    the architecture. Vector embeddings are the common choice, but lexical
    (tf-idf, BM25, SQLite FTS5) "can serve as the retrieval backend."
    - You note the vector trade-off directly: higher compute, reduced
    debuggability — in exchange for cross-lingual / semantic hits ("knowledge
    cycle" matching "Wissenszyklus").
  
    2. Hybrid search, fused by RRF, is the production answer.
    - 202603280655 RRF Reciprocal rank fusion.md — you chose RRF because it
    sidesteps the score-normalization problem (BM25 unbounded, cosine 0–1) by
    ranking-only fusion. The k=60 dampening makes it so a document has to appear
    across methods to win. This is a quietly strong claim: you don't think vector
    search alone is enough.
    - 202412071908 BM25 search ranking.md and 202412071858 … tf-idf.md — the
    lexical half of hybrid. You keep the older Zac Romero (EmacsConf 2024) lineage
     alive here, which is why your RAG notes reach for BM25 as a first-class peer
    to embeddings.
  
    3. The Zettelkasten/RAG mapping — and where each has blind spots.
    - 202603280645 Zettelkasten and RAG.md is the synthesis hub. You draw a table
    aligning atomicity ↔ chunking, tags ↔ lexical index, links ↔ graph retrieval,
    structure notes ↔ parent-document retrievers, synthesis ↔ generation, GIGO ↔
    garbage retrieval.
    - Your sharpest claim lives here: hand-curated structure notes encode 
    intentionality that embedding similarity cannot replicate. The inverse is
    equally honest — vector search finds unlinked cross-cluster connections a
    Zettelkasten has no edge for. You even propose the experiment: embed
    everything, query with vector search, diff against structure-note traversal.
    The delta is the research question.
  
    The thread connecting all three: you treat vector similarity as a complement,
    not a replacement — for lexical ranking (via RRF), and for human-authored
    links (via the ZK↔RAG mapping). The consistent move is skepticism toward any
    single retrieval signal.
  
    Gaps worth noting: no standalone note on vector databases as infrastructure
    (FAISS, pgvector, HNSW, chunking strategy, embedding model choice). If you
    want one, 202603280646 is the natural parent to link from.
  
  ✻ Crunched for 1m 7s
  

  Higher-level stuff

  Another example for deep research my zettelkasten for connections of software architectute and Zettelkasten patterns

  ❯ deep research my zettelkasten for connections of software architectute and    
    Zettelkasten patterns                                                         
  
  ⏺ Skill(ta-deep-research)
    ⎿  Successfully loaded skill
  
  ⏺ Bash(ta --help 2>&1 | head -50)
    ⎿  OVERVIEW: Zettelkasten retrieval CLI for coding agents.
  
       EXAMPLES:
       … +25 lines (ctrl+o to expand)
  
  ⏺ Bash(ta search "software architecture" --depth 1 2>&1 | head -100)
    ⎿  - ref: "201606161929 ReSwift doesn't impose architectural constraints.
       md"
         title: "ReSwift doesn't impose architectural constraints"
       … +45 lines (ctrl+o to expand)
  
  ⏺ Bash(ta search --phrase "Zettelkasten" --phrase "software" 2>&1 | head -80)
    ⎿  - ref: "201009241818 Introducing Notational Velocity with MultiMarkdow
       n support.md"
         title: "Introducing Notational Velocity with MultiMarkdown support"
       … +108 lines (ctrl+o to expand)
  
  ⏺ Bash(ta search --phrase "pattern language" --depth 1 2>&1 | head -80)
    ⎿  - ref: "202501301159 § Pattern Language for Zettelkasten.md"
         title: "§ Pattern Language for Zettelkasten"
         snippet: "https://notes.andymatuschak.org/z79rMNNuLrUj6R8q1CXSpDm
       … +120 lines (ctrl+o to expand)
  
  ⏺ Bash(ta show "202501301159 § Pattern Language for Zettelkasten.md"
        "202209211603 § Zettelkasten for programmers.md" "202210081852 Complexity
        is required in code base…)
    ⎿  ---
       ref: "202501301159 § Pattern Language for Zettelkasten.md"
       title: "§ Pattern Language for Zettelkasten"
       … +391 lines (ctrl+o to expand)
  
  ⏺ Bash(ta show "202501301159 § Pattern Language for Zettelkasten.md" 2>&1 | tail
         -250)
    ⎿  - Solution: Write your notes so that they can be composed with other n
       otes into new texts, making each note a movable text fragment.
           - Movable type made it possible to assemble pages from smaller pie
       … +250 lines (ctrl+o to expand)
  
  ⏺ Bash(ta show "202209211603 § Zettelkasten for programmers.md" "202210081852
        Complexity is required in code bases and Zettelkasten alike.md" 2>&1)
    ⎿  ---
       ref: "202209211603 § Zettelkasten for programmers.md"
       title: "§ Zettelkasten for programmers"
       … +93 lines (ctrl+o to expand)
  
  ⏺ Bash(ta show "202404061208 Avoid implicit themes in your Zettelkasten.md"
        "202308011922 Locality of change in software.md" "202406132000 Structure
        vs Process in Zett…)
    ⎿  ---
       ref: "202404061208 Avoid implicit themes in your Zettelkasten.md"
       title: "Avoid implicit themes in your Zettelkasten"
       … +116 lines (ctrl+o to expand)
  
  ⏺ Bash(ta show "202210171300 Zettelkasten as API needs entry points.md"
        "202111291403 Gall's Law working systems always start simple.md"
        "202403141330 Zettelkasten tra…)
    ⎿  ---
       ref: "202210171300 Zettelkasten as API needs entry points.md"
       title: "Zettelkasten as API needs entry points"
       … +51 lines (ctrl+o to expand)
  
  ⏺ Software architecture ↔ Zettelkasten in your archive
  
    Your thinking on this maps cleanly to four themes, all orbiting one big
    synthesis note.
  
    1. Christopher Alexander is the explicit bridge.
    The centerpiece is a deliberately-constructed pattern language:
    - 202501301159 § Pattern Language for Zettelkasten.md — your largest §-note on
     the topic. Quotes Alexander 1977, organizes Zettelkasten patterns
    largest-to-smallest (Zettelkasten → Departments → Structures → Notes → Content
     → Language → Technology), and lifts pattern names straight from software:
    "Single Responsibility, Separated Concerns", "Boy Scout Rule", "Immutable
    Storage", "Rule of Three", "Algorithmic Solutions", "Signal vs Noise Ratio".
    - 202503090539 Cockburns medical pattern language metaphor components.md —
    Cockburn's Patterns of Project Management as another import of Alexander's
    grammar.
  
    2. Software antipatterns port to Zettelkasten antipatterns.
    - 202404061208 Avoid implicit themes in your Zettelkasten.md — explicitly maps
     the "incidental data structure" programming antipattern onto your
    Zettelkasten; proposes "Concept-Free Note-Taking" by analogy to Concept-Free
    Programming. Heuristic: lack of an address is an indicator the idea isn't 
    expressed directly.
    - 202308011922 Locality of change in software.md → reused as the structural
    basis for "Single Responsibility, Separated Concerns" in the pattern-language
    note. SRP is about change, not essence; atomicity of a Zettel is the
    knowledge-system analogue.
  
    3. Structure/Process as a unifying principle across both.
    - 202209232058 Struktur und Prozess von Strukturen und Prozessen in der 
    Programmierung.md — treats Structure×Process as a cross-product applicable to
    code (static/runtime, module boundaries shifting over coding time) and equally
     to knowledge work.
    - 202406132000 Structure vs Process in Zettelkasten for Programmers.md —
    Atom/Molecule/Organism granularity (Zettel / Structure Note / Project), plus
    Rule-of-Three extraction before refactoring into a shared theme.
    - 202111291403 Gall's Law working systems always start simple.md — complexity
    evolves from a simple working seed, applied to both codebases and
    Zettelkästen.
  
    4. Zettelkasten as black-box software system.
    - 202210171300 Zettelkasten as API needs entry points.md — departments are
    black boxes; structure notes are published API; readers (future-you) interact
    through curated entry points.
    - 202209211603 § Zettelkasten for programmers.md — the programmer-facing hub.
    Ties it together: "Tame complexity like a programmer … Make implicit
    structures visible with structure notes, similar to extracting a service
    object."
    - 202210081852 Complexity is required in code bases and Zettelkasten alike.md
    — the one-liner version: you don't see benefits of a software architecture 
    before the complexity crosses a threshold — same for a Zettelkasten.
  
    The connecting thread visible in the bodies: you treat the Zettelkasten as a
    long-lived software system. Alexander's pattern grammar
    (Context/Problem/Forces/Solution/Related) gives the shared formal vocabulary,
    and programming principles port because both must scale complexity
    sustainably: SRP ⇢ atomicity, locality of information ⇢ movable text
    fragments, immutability ⇢ stable addresses, boy-scout rule ⇢ malleable notes,
    Gall's Law ⇢ start simple and grow, black-box encapsulation ⇢ department entry
     points. The explicit claim in § Pattern Language for Zettelkasten is that the
     language itself is the deliverable — a shared vocabulary for people designing
     tools for thought.
  
    If you want to push further, two probes I did not follow: (a) 202308241058 
    Concept-Free Programming.md paired with the antipattern note, and (b) the
    "Value Creation in Zettelkasten" / Feynman's Darlings chain from 202406132000,
     which looked like it connects to a product-engineering frame you haven't
    fully laid out yet.
  
  ✻ Worked for 1m 33s
  

  Observations

  One thing that sticks out is the limit to | head -80, limiting the output of searches to 80 lines where each search result takes up a couple of lines can easily miss details.

  Ideas to improve this:

  • adjust the skill to avoid introducing a limit
  • change output to jsonl oneliners, so a limit of 80 would produce 80 results, which is better than ~20 or so you get now

  That's probably Claude Opus 4.7 trying to be clever and save tokens 🤔

  Author at Zettelkasten.de • https://christiantietze.de/
• ctietze

  April 19 edited April 19

  Deep Research with GPT-5.4 High Thinking using pi

  I really really really like the pi agent harness. It's barebones, but you just ask it to create the features you need, and then it happily augments itself. Malleable software! It's a joy to work with.

  Same prompt as above, including the typo I just noticed now

   deep research my zettelkasten for connections of software architectute and Zettelkasten patterns
  

  Since Anthropic killed Claude subscription access outside of their products, I'm using OpenAI here to test everything. The output export is super detailed in comparison to Claude's command line output by default, and GPT is much wordier without a harness making it summarize the findings. See below for the final result.

  At the end, GPT-on-pi suggested to create artifacts from the results:

  If you want, I can next turn this into one of these:
  

  • a concept map
  • a chronological evolution of this idea in your notes
  • a short essay in your own voice with citations

  I ordered all three suggestions (attached to this post for you to peek at). The concept map was just another Markdown file, so I then ordered a PNG via graphviz:

  

  Let's just say that @Edmund's graphs look nicer

  GPT-on-pi's rather long result

  I dug through your archive around `software architecture`, `zettelkasten`, `pattern-language`, and `programming`, then read the main hub notes.
  
  ## Big picture
  
  Your notes make a strong, repeated claim:
  
  **A Zettelkasten becomes architecture work once it grows past a certain complexity threshold.**  
  At that point, the important questions stop being “how do I store notes?” and become:
  
  - how do I expose good entry points?
  - how do I keep concepts addressable?
  - how do I localize change?
  - how do I refactor structure without breaking the network?
  - how do I balance hierarchy with cross-cutting connections?
  
  That thread is very explicit in:
  
  - `"202210081852 Complexity is required in code bases and Zettelkasten alike.md"`
  - `"202210171300 Zettelkasten as API needs entry points.md"`
  - `"202404061208 Avoid implicit themes in your Zettelkasten.md"`
  - `"202501301159 § Pattern Language for Zettelkasten.md"`
  
  ## The main connection clusters
  
  ### 1. Complexity is the precondition for architecture
  Your bridge note is `"202210081852 Complexity is required in code bases and Zettelkasten alike.md"`:
  
  - software architecture only shows its benefits once a codebase is complex enough
  - same for a Zettelkasten: you need enough internal complexity before “interesting things happen”
  
  That idea gets picked up again in `"202209211603 § Zettelkasten for programmers.md"`:
  - treat the archive like a growing knowledge garden
  - “tame complexity like a programmer”
  - nourish structures before expecting higher-order effects
  
  So in your archive, **software architecture and Zettelkasten practice are parallel responses to emergent complexity**.
  
  ---
  
  ### 2. Entry points, APIs, and black boxes
  One of your clearest cross-domain mappings is:
  
  - **public APIs in software**
  - **curated entry points in a Zettelkasten**
  
  `"202210171300 Zettelkasten as API needs entry points.md"` says this directly:
  - entry points are like published APIs into a module
  - overviews/summaries/visualizations make large “departments” accessible
  - the archive is too large to be practically accessible without curation
  
  This pairs well with `"202404061116 § Software Architecture.md"`:
  - architecture is constructing structures
  - those structures constrain processes observable at runtime
  
  And it connects to `"202209232058 Struktur und Prozess von Strukturen und Prozessen in der Programmierung.md"`:
  - modules/black boxes statically bound the space of possible runtime behavior
  
  So one of your strongest themes is:
  
  **A mature Zettelkasten needs architecture-level interface design.**  
  Not every note should be an entry point, just like not every function should be public API.
  
  ---
  
  ### 3. Atomicity, SRP, and locality of change
  You repeatedly map note design onto software modularity.
  
  `"202404061208 Avoid implicit themes in your Zettelkasten.md"` frames hidden concepts as the note-taking equivalent of an anti-pattern:
  - an implicit shared theme is like an incidental data structure
  - if an idea has no address, it can’t be cleanly linked, named, or reasoned about
  
  `"202308011922 Locality of change in software.md"` gives the software side:
  - SRP means one reason to change
  - information should be local, not smeared across modules
  
  `"202401112021 Level of detail in Zettelkasten possibly infinite compared to publications.md"` gives the Zettelkasten side:
  - atomic notes improve focus
  - smaller units make extension points easier to find
  - granularity determines what level of problem analysis is possible
  
  `"202406132000 Structure vs Process in Zettelkasten for Programmers.md"` then formalizes this:
  - atom = Zettel
  - molecule = structure note
  - organism = project
  - process = capture → connect → extract
  
  This cluster suggests your archive sees **atomicity as the Zettelkasten analogue of modular design**:
  - SRP → one reason to change
  - atomicity → one focus / one movable unit
  - locality → explicit concepts live in one addressable place
  
  ---
  
  ### 4. Heterarchy instead of a single master hierarchy
  Your notes reject the idea that a Zettelkasten should have one total top-down architecture.
  
  `"202208081113 Polyhierarchy in Zettelkasten through glue notes.md"` is especially important:
  - a note should be separated from its contextual embeddings
  - representation-of-a-thing and hierarchy-placement are different concerns
  - “glue notes” or adapters bring a thing into context
  
  That is a very software-architectural move:
  - core entity vs adapter layer
  - object vs context
  - module vs integration surface
  
  `"202501301159 § Pattern Language for Zettelkasten.md"` develops this into:
  - heterarchy, not strict hierarchy
  - departments, highways, trails, entry points
  - maps of content and formal relationships as navigational architecture
  
  So your archive treats Zettelkasten structure less like a file tree and more like a **system of overlapping bounded contexts**.
  
  ---
  
  ### 5. Refactoring discipline: wait for utility, then extract
  Your Zettelkasten patterns borrow software refactoring heuristics surprisingly directly.
  
  From `"202406132054 Prinzip Warten auf Nützlichkeit bis man Strukturen ändert.md"`:
  - wait for utility before deepening or restructuring
  - don’t chase every rabbit hole
  - connect this to the rule of three
  
  From `"202501301159 § Pattern Language for Zettelkasten.md"`:
  - “rule of three”
  - “boy scout rule”
  - malleable notes
  - explicit themes
  - pattern language as shared vocabulary
  
  This means your archive does **not** treat structure as something fixed up front.  
  Instead, structure is something you:
  - let emerge,
  - observe under load,
  - then refactor when repeated use proves utility.
  
  That is basically architecture-as-evolution, not architecture-as-blueprint.
  
  ---
  
  ### 6. Links and titles behave like contracts
  Another deep bridge is interface contract thinking.
  
  `"202503100756 Contractual Obligation in note networks.md"` says:
  - a note should not lie about its content
  - in a link `A→B`, the link context in `A` creates an expectation of `B`
  - changing `B` can violate the network contract
  
  `"202503100755 Promise of the Note Title.md"` pairs title with promise/API.
  
  That maps neatly to software architecture:
  - link context ≈ caller expectation
  - note title/content ≈ interface/implementation contract
  - backlinks ≈ impact analysis
  
  So your archive sees **note maintenance as dependency management**.
  
  ## Strongest synthesis
  
  The clearest synthesis I see is this:
  
  **Your Zettelkasten is treated as a software system for thought, and software architecture is treated as a pattern language for managing complexity, access, change, and meaning inside that system.**
  
  More specifically:
  
  - **Architecture** gives you:
    - interfaces
    - structure/process thinking
    - locality of change
    - refactoring discipline
    - contract awareness
  
  - **Zettelkasten** gives you:
    - addressable ideas
    - heterarchical composition
    - movable/atomic units
    - emergent structure
    - long-term discoverability
  
  And your notes increasingly merge them into one view:
  **designing a note network is architectural work.**
  
  ## Best notes to revisit
  
  If you want the tightest reading list on this connection, start with:
  
  1. `"202210081852 Complexity is required in code bases and Zettelkasten alike.md"`
  2. `"202210171300 Zettelkasten as API needs entry points.md"`
  3. `"202404061208 Avoid implicit themes in your Zettelkasten.md"`
  4. `"202308011922 Locality of change in software.md"`
  5. `"202208081113 Polyhierarchy in Zettelkasten through glue notes.md"`
  6. `"202406132000 Structure vs Process in Zettelkasten for Programmers.md"`
  7. `"202501301159 § Pattern Language for Zettelkasten.md"`
  8. `"202503100756 Contractual Obligation in note networks.md"`
  
  If you want, I can next turn this into one of these:
  
  - a **concept map**
  - a **chronological evolution of this idea in your notes**
  - a **short essay in your own voice with citations**
  

  Post edited by ctietze on April 19

  Author at Zettelkasten.de • https://christiantietze.de/
• Andy

  April 19

  The LLM output here sounds to me like someone who knows @ctietze's thinking.
• ctietze

  April 20

  I removed the link when editing my post by accident, here are the 3 artifacts in text form:

  https://gist.github.com/DivineDominion/593e1f6b3412148617368e12f9a6121c

  @Andy it does sound somewhat insightful and detailed, and well, it's wordy at least! Was a surprise to read this kind of output, because it's not in my Zettelkasten. And some (obvious in hindsight) connections aren't expressed as cleanly -- like how the similarity of a Zettelkasten and API design fit well with "not everything needs to be public" (in programming) and by conversion not every note needs to be an entry point in the Zettelkasten.

  So far it's not a waste of time to use this, but GPT's tendency to be so verbose can quickly turn into getting tired of dealing with the output

  Author at Zettelkasten.de • https://christiantietze.de/
• ctietze

  April 20

  Deep research, same prompt, Mistral Vibe using devstral-2

  Mistral is a EU provider of LLM services -- apparently heavily subsidized, as they're giving away access to their coding agent for free (!!!!) with some reasonable rate limits.

  Mistral replies fast.

  If you want to experiment with coding agents, I recommend to set up a Mistral account and then download the vibe CLI and use that for a taste.

  ---

  Same prompt as above, including the typo:

   deep research my zettelkasten for connections of software architectute and Zettelkasten patterns
  

  The reply:

  Your Zettelkasten reveals **six deep connections** between software architecture and Zettelkasten patterns:
  
  ---
  
  ## 1. Complexity Threshold
  Both systems require complexity to demonstrate architectural value.
  
  > You don't see benefits of a software architecture before the complexity of the code base reaches a certain threshold. [...] Like a code base requires a certain complexity to show *complex behavior*, you need to write prose in a Zettelkasten for a while before you can judge if it can do complex stuff.
  > — `202210081852 Complexity is required in code bases and Zettelkasten alike.md`
  
  ---
  
  ## 2. Hypertext as Unifying Metaphor
  Both Zettelkasten and software are **interconnected hypertext networks**.
  
  **Zettelkasten**: Three link types per Luhmann:
  - Keyword references (generalization via tags)
  - Explicit ID links (direct connections)
  - Spatial hypertext (sequential: `52/7a4` → `52/7a5` → `52/7a6`)
    — `201105201217 Arten von Links im Zettelkasten.md`
  
  **Software**:
  > You have many interconnected pieces; you can follow trails through the code base, but cannot grasp everything at once, the way through the hypertext is up to you and also formative
  > — `202401182137 Software as hypertext.md`
  
  Both require navigation trails rather than static 2D diagrams: `202401182128 Diagrams don't reflect software.md`
  
  ---
  
  ## 3. Structure vs Process (Unifying Principle)
  A meta-pattern that organizes thinking across both domains.
  
  | Aspect | Software | Zettelkasten |
  |--------|----------|--------------|
  | **Structure** | Module boundaries, layered architecture | Note structure, index/structure notes |
  | **Process** | Runtime behavior, state transitions | Note-taking workflow, idea evolution |
  | **Structure of Structure** | Higher-level module partitioning | Department/entry point organization |
  | **Process of Structure** | Evolution of codebase boundaries | Changing note relationships over time |
  
  > The difference between structure and process is a unifying principle. [...] If you want to, you can see it everywhere
  > — `202406131954 § Structure vs Process unifying principle.md`
  
  Applied to Zettelkasten: `202406132000 Structure vs Process in Zettelkasten for Programmers.md`
  
  Applied to programming: `202209232058 Struktur und Prozess von Strukturen und Prozessen in der Programmierung.md`
  
  ---
  
  ## 4. Modularity: Black Box Thinking
  **Software**: The black box principle unifies module design.
  
  > Treating units at face-value of their abstraction, characterized by: boundary, input, output. Modules on all levels: functions, classes, services.
  > — `201610081507 Black Box unifies the whole of software modelling in modules.md`
  
  **Zettelkasten**: Notes as black boxes.
  
  > A note should be a self-contained unit with clear boundaries, inputs (what it references), and outputs (what it enables).
  > — Implicit in linking patterns
  
  Connected via: Layered software architecture relies on black box modules (`201610091107 Layered software architecture.md` links to black box)
  
  ---
  
  ## 5. Granularity Patterns: Atom/Molecule/Organism
  A chemistry metaphor applied to both domains.
  
  | Level | Zettelkasten | Software/Design |
  |-------|--------------|-----------------|
  | **Atom** | Single Zettel (one thought) | Function, SRP-compliant module |
  | **Molecule** | Structure note (connects atoms) | Component, class, service |
  | **Organism** | Project/writing output | Application, system |
  
  > The chemistry metaphor of Atom/Molecule/Organism can be applied to focus on different levels of granularity. [...] In a Zettelkasten, viewed as a tool for thinking, operates on the unit of Zettel. A Zettel can be an Atom, it can be a structure note (Molecule), or a writing project (Organism).
  > — `202403131049 Atom, molecule, organism metaphor of granularity.md`
  
  Also connects to:
  - `202308092113 One thought per unit of writing is atomicity.md` (SRP for notes)
  - `201302161820 Single Responsibility Principle.md` (SRP for code)
  
  ---
  
  ## 6. Linking Dependencies
  **Zettelkasten**: Explicit linking enables emergence.
  
  > Verweisung auf andere Zettel durch explizite Links, über deren ID
  > — Luhmann's three link types, `201105201217 Arten von Links im Zettelkasten.md`
  
  **Software**: Dependency types mirror link types.
  
  | Zettelkasten Link | Software Equivalent |
  |-------------------|---------------------|
  | Tag-based | Interface/abstract type (generalization) |
  | Explicit ID link | Direct import/dependency |
  | Spatial (sequential) | Module layering (ordered dependencies) |
  
  > Each layer has a clear meaning. [...] The dependency between layers is strictly ordered. Criss-crossing dependencies invite sloppy separation.
  > — `201610091107 Layered software architecture.md`
  
  ---
  
  ## 7. Living Systems
  Christopher Alexander's architecture theory applies to both:
  
  > These centers are more living, or less living. [...] recursive, perceptible entities [...] its "livingness" depends on subsumed centers
  > — `202501301155 Alexander's architecture entities are differentiate on degrees of livingness.md`
  
  Parallel to Zettelkasten: notes gain "livingness" through recursive connection, a network of notes is more living than isolated notes.
  
  ---
  
  ## 8. Practical Synthesis: Zettelkasten as Programmer's Tool
  
  **Lab Notebook**:
  > As a programmer, I use my Zettelkasten like a laboratory notebook [...] I take meticulous note of observations: stack traces, side effects, inputs and outputs.
  > — `202209211601 Zettelkasten as lab notebook for programmer.md`
  
  **Compost Metaphor**:
  > The Zettelkasten is your compost pile. The germination process is how ideas processed into pieces of knowledge are available for re-combination.
  > — `202210011144 Compost everything you learn in your Zettelkasten.md`
  
  **Complexity Management**:
  > Knowledge networks require pruning instead of graphing. [...] Think globally, link locally.
  > — `20230317 Knowledge networks require pruning instead of graphing.md`
  
  ---
  
  ## Architectural Pattern Mapping
  
  | Software Architecture Pattern | Zettelkasten Equivalent |
  |--------------------------------|------------------------|
  | Layered Architecture (`201610091107`) | Note hierarchies ( departments, topics) |
  | Black Box / Module (`201610081507`) | Self-contained notes |
  | SRP / Cohesion (`201302161820`) | One thought per note |
  | Dependency Inversion (`201305031947`) | Bidirectional linking (backlinks) |
  | Hexagonal/Ports & Adapters (`201407071042`) | Entry points with clear interfaces |
  | Anti-Corruption Layer (`202202091507`) | Translation notes between domains |
  
  ---
  
  ## Synthesis
  Your thinking reveals **isomorphism**: both software systems and Zettelkasten are:
  - **Hypertext networks** requiring navigation not visualization
  - **Modular systems** where boundary design matters
  - **Living systems** that evolve through structured complexity
  - **Granular hierarchies** operating at multiple levels of abstraction
  
  The strongest explicit connection: **Complexity is the catalyst** that makes architecture (in both code and notes) worthwhile.
  
  Want to explore any specific theme deeper?
  

  Author at Zettelkasten.de • https://christiantietze.de/
• ctietze

  April 28

  I've sprinkled in some 'deep research my Zettelkasten' sentence fragments in recent programming tasks and the skill detection works well.

  Some results genuinely surprise me; the output favors mentioning sources only by ID, which isn't as useful if you can't click them

  But traversing the graph is no problem.

  So we have:

  • LLM to look for entry points with search
  • CLI to surface content and connections
  • LLM to traverse connections, hop-by-hop

  I haven't tuned the settings, i.e. whether to favor a depth of 1 hop per query, or 3, or 5 or however many. Still experimenting.

  For topics where some notes exist, but my thinking is still fragmented, the LLM's overly confident tone shows its flaws. What You See Is All There Is (Kahnemann) on the LLM's side: because there's only a one-sided, two bullet-point overview of a new-to-me topic, it treats this limited perspective as gospel.

  So balances need to be added.

  Author at Zettelkasten.de • https://christiantietze.de/
• ctietze

  May 22

  Updated recently to make search more similar to The Archive (which means: more loose in a way)

  Author at Zettelkasten.de • https://christiantietze.de/
• Will

  May 25

  After a few minutes of searching for a .pkg file and then seeing the local build command, I got ta installed. Being an old man, I stumbled with the .config/config.yaml file, but now all is well and running the ta command doesn't invoke an error message. My problem is that no matter which sample command from the help I use, I get an empty [] as the return. Is there a test I can run? Here is the output.

  `❯ ./ta search thinking --depth 2

  []`

  Will Simpson
  My peak cognition is behind me. One day soon, I will read my last book, write my last note, eat my last meal, and kiss my sweetie for the last time.
  My Internet Home — My Now Page
• ctietze

  May 26

  @Will thanks for giving it a shot! This is the output I get (knowing that I have notes on the topic ) when I provide a path that exists but doesn't actually contain any text files with that content, e.g.:

  ta search thinking --depth 2 --archive "~/Documents"
  

  But the actual reason could be that you use .txt files and the tool looks for .md only. I forgot to push the latest update as a downloadable release. Check out 0.2.0 on the release downloads page: https://github.com/Zettelkasten-Method/ta/releases/tag/0.2.0

  Author at Zettelkasten.de • https://christiantietze.de/
• Will

  May 26 edited May 26

  Still not working. I get a blank set as a return. My zettels use the .md extention. I downloaded and installed "ta-0.2.0-macos-universal.pkg", and I have over 1,200 zettels with "thinking" as a term. Who knew a person could write so much about thinking? Looks of navel-gazing in there, I'm sure.

  ta search thinking --depth 2 --archive "~/Dropbox/zettelkasten"

  Is there something about the title format requirements that might be the issue? My title format is: "Thinking About Thinking - Cognative Distancing 202506252102". The file name is the same with the .md extension.

  I tried searching for the term "allostatic," which is not in my zettelkasten yet, and I get a blank set as well. It seems like ta is not searching in my zettelkasten.

  Will Simpson
  My peak cognition is behind me. One day soon, I will read my last book, write my last note, eat my last meal, and kiss my sweetie for the last time.
  My Internet Home — My Now Page
• ctietze

  May 27

  @Will Yes, ID at the end breaks the lookup! Will send an update soon

  Author at Zettelkasten.de • https://christiantietze.de/
• ctietze

  May 28

  @Will Check out the latest 0.3.0 please https://codeberg.org/ctietze/ta/releases/tag/0.3.0

  Author at Zettelkasten.de • https://christiantietze.de/
• tomp

  May 28

  @Will said:

  `❯ ./ta search thinking --depth 2

  This search seems to be the equivalent of the "Concise Bounded Description" (CBD) which was proposed for the Resource Description Framework (RDF). IIRC, it was originally devised by Patrick Durusau. Basically, a CBD means everything that refers to the original target, plus for each of those, everything that refers to them, and so on to a specified depth. There is no reason why the concept has to be limited to RDF.

  I have implemented a very rough prototype of a CBD in my system. I'm still experimenting.
• Will

  May 29

  Oh joy!! I’m so excited to be part of this team! I ran ta looking for the variable Emerson and found that when I redirected the output to a file, I got a 1.4MB file. When I added the --depth 2 switch, thinking that it would be bigger, I got a 645KB file. It seemed weird until I looked at the output and saw that without a depth parameter, I was getting depth 3.

  Feature request: Have the stdout display the number of hits per level.

  Now I’m going to look at the ta agent skills. I'm favoring CODEX for the time being. It is going to take this geezer a while to digest the agent instructions in the skills section of ta-deep-research/SKILL.md. Any tips for me?

  Will Simpson
  My peak cognition is behind me. One day soon, I will read my last book, write my last note, eat my last meal, and kiss my sweetie for the last time.
  My Internet Home — My Now Page
• Will

  May 29

  First Pass

  I got this going! It focused on my zettelkasten, and produced a clear and readable text. I sense I'll be changing the tone the skill's agent is using. This is fascinating.

  Codex Prompt:

  Do a deep research pass through my notes on "attention horizon". Start broad, follow promising links, then give me themes, tensions, and open questions.

  Return

  I did a broadtapass onattention horizon`, then followed the strongest links through mindfulness, devotion, algorithmic attention, writing environment, patience, and later notes on the attentional commons.

  Source base: Attention Horizon 202012070703, Attention Autonomy 202012151748, A-Attention Is The Beginning Of Devotion 202006230814, Moments Of Attention Just Happen 202107090513, » Algorithms Rule Human Attention 202011201035, » Two Ways Mindfulness Can Improve Life 202011232030, Priority of attention 201902041012, » Has Time Been Well Spent? 202011152024, Shaping my writing environment 202202060916, The Power of Patience 202206132144, A preoccupation is useful for the mind 202601060859, Defending the Attentional Commons 202411300539, Everything is Becoming Television 202510310637.

  Core Idea
  “Attention horizon” seems to mean: an inner orientation instrument that tells you where attention is currently distributed relative to intention.

  The aircraft metaphor in the central note is doing real work. It is not just “focus harder.” It is: notice whether your attention is tilted, drifting, too close, too far, too tense, too diffuse, or no longer aligned with what you claim matters. The concept includes foreground/background attention, temporal distance, spatial distance, and moral priority.

  Your examples are revealing: kindness should be close on the horizon; meditation off the cushion should be brought closer through practice; writing sits farther out but is actionable. So the horizon is a map of what is psychically near enough to shape behavior.

  Themes
  1. Attention is identity formation.

  Attention Autonomy says what you pay attention to makes you who you are, partly through neuroplastic reinforcement. Algorithms Rule Human Attention makes the same point in algorithmic language: your mind has a recommendation system too. You get more of what you click on internally.

  The implication: attention horizon is not a passive readout. It is self-making infrastructure.

  2. Attention is devotion, not just cognition.

  Attention Is The Beginning Of Devotion treats attention as the beginning of love, care, and nourishment. “The unnoticed can’t be loved” is the strongest compressed claim in this branch. The attention horizon is therefore also an affection horizon: what is close enough to be cared for?

  This gives the concept an ethical charge. Squandered attention is not merely inefficiency; it is misdirected devotion.

  3. Attention has to be defended environmentally.

  The notes repeatedly move from personal discipline to external design. Shaping my writing environment says control the environment to control writing. Defending the Attentional Commons scales that up socially: silence is the condition that lets thinking happen. Everything is Becoming Television names the newer threat: infinite passive flow becoming the background of life.

  So the horizon is not only “inside the head.” It is co-produced by rooms, screens, peers, silence, habits, and commercial systems.

  4. Mindfulness changes the horizon by creating space.

  Two Ways Mindfulness Can Improve Life says mindfulness helps you ask whether something is worth doing, and also lets unpleasant or unavoidable moments become sites of freedom. Moments Of Attention Just Happen adds a subtler dzogchen move: attention is already moving; the question is what notices the movement.

  That means calibration is partly intentional and partly receptive. You steer attention, but you also learn to notice its self-arising motion.

  5. Patience extends the horizon.

  The Power of Patience is a crucial side branch. It argues that real seeing takes time, and that delay can become an active cognitive state. This deepens attention horizon from “what am I focused on?” into “what temporal scale am I capable of inhabiting?”

  A short attention horizon collapses into immediacy. A cultivated one can hold projects, questions, relationships, and slow transformations.

  6. Writing is a horizon-shaping machine.

  A preoccupation is useful for the mind makes writing the way curiosity gathers force. A piece of writing in mind becomes a “windmill of thought”: it catches stray perceptions and makes them coherent. This links strongly with Ask Questions That Concentrate Focus.

  So one practical answer in your notes is: to change the attention horizon, install a question or writing project that makes the world start presenting relevant material.

  Tensions
  1. Steering vs letting be.

  Some notes say shepherd attention like an adult. Others, especially Huang Po and dzogchen notes, warn against discriminating, pondering, or over-directing the mind. There’s a live tension between attention as disciplined steering and attention as non-grasping awareness.

  A synthesis might be: steer the conditions and intentions, then relax the grip inside experience.

  2. Focus vs diffuse attention.

  Attention And Distraction Are Inversely Related complicates the binary. It suggests focused and diffuse modes feed each other, and that a “distraction” may move between foreground and background. This challenges a simplistic productivity reading.

  Maybe a healthy attention horizon is not narrow; it is legible, responsive, and intentionally spacious.

  3. Personal responsibility vs attention economy.

  Priority of attention emphasizes adult responsibility: steer your focus. But Defending the Attentional Commons, Attention as an economic resource, and Everything is Becoming Television show that attention is aggressively harvested. The tension is between sovereignty and ecology.

  Your notes seem to reject victimhood, but they also refuse the fantasy that attention is purely individual willpower.

  4. Present-moment meaning vs long-range projects.

  Has Time Been Well Spent? says meaning comes from quality of attention in any moment. But Attention Horizon explicitly includes distant plans, traits, habits, and writing. The tension: should attention come home to now, or stretch toward future commitments?

  Possible synthesis: the future belongs on the horizon, but the only place to adjust the instrument is now.

  Open Questions

  • What are the dimensions of an attention horizon? Near/far, tense/relaxed, chosen/captured, personal/social, present/future, nourishing/extractive?
  • Can you make a daily “attention horizon check” that is not another productivity ritual?
  • What belongs close on the horizon by default: kindness, writing, body, spouse/friends, silence, reading, practice?
  • What should stay distant but visible, so it guides without creating anxiety?
  • How do you tell the difference between a worthy preoccupation and an obsession that has captured the system?
  • What environments reliably bring writing, kindness, and meditation closer?
  • What kinds of silence are necessary: acoustic silence, screen silence, social silence, commercial silence?
  • Can “attention horizon” become a writing framework: What am I noticing? What am I neglecting? What is trying to buy the foreground?
  • How does the horizon change under fatigue, loneliness, fear, or novelty?
  • What would an “attentional commons” look like at the scale of a household, classroom, website, city, or writing group?

  My read: “attention horizon” is one of your better bridge concepts. It connects mindfulness, writing, anti-distraction, patience, environment design, and moral life without reducing attention to productivity. It says: know what is near, know what is steering you, and keep bringing the worthy things back into view.
  `

  Will Simpson
  My peak cognition is behind me. One day soon, I will read my last book, write my last note, eat my last meal, and kiss my sweetie for the last time.
  My Internet Home — My Now Page
• ctietze

  May 29

  @Will said:
  Feature request: Have the stdout display the number of hits per level.

  To not pollute the output (for tool consumption) this could make sense in a filter, i.e. a piped program so you essentially write do the search | filter, and the filter would print the count for you. That could be a Python script if you like. To not break the tool's pipe-ability, you could write a script that creates a file with the evaluation results and just passes the original input through.

  Now I’m going to look at the ta agent skills. I'm favoring CODEX for the time being. It is going to take this geezer a while to digest the agent instructions in the skills section of ta-deep-research/SKILL.md. Any tips for me?

  You solved this already but the general recommendation is to just ask the agents to do it for you

  Author at Zettelkasten.de • https://christiantietze.de/