Mike's Notes
The problem
The remaining main barrier to people using Pipi is the lack of user documentation.
I need a way to quickly generate thousands of pages of technical documentation for Pipi 9. I'm too slow to write the documentation; it's mentally exhausting. Now I know why. 😎
Pipi 9 is a very large, complex system with many moving parts.
"novel symbolic and evolutionary AI engine that uses formal ontologies to deterministically generate enterprise software"
Finding a solution
I copied part of the About Me description and used it as a prompt for Google Search AI Mode (Gemini). Below is the transcript after I ran it through Grammarly.
I thought the generated response was accurate, aligned with published, verified research, and offered lots of practical suggestions to try. Some are already underway.
Aftermatch
Later, I ran the same prompts again several times on clean new sessions and got similar variations in the generated response. You can try it as well.
Node-link graphs
Get Pipi to use data-driven templates to generate interactive 2D or 3D node-link graphs using tools like;
- Mermaid.js (already planned)
- D3 (to do)
- Cytoscape (to do)
I need to generate the templates with Gemini's help. 😎
Colour-Coded Architecture Diagrams
The thousands of drawings are on A4 white paper, drawn with a ballpoint pen and stored in 3-hole ring binders. Use coloured A4 paper as headings, section and subsection dividers.
Define a strict colour scheme that works with 6 Stabilo Boss original highlighters carried in a small pencil case to colour the pen drawings;
- Pink: Agent/system
- Green: Data
- Orange:
- Blue: Relationship
- Yellow:
- Red:
3D Visualisation
Enable fly-throughs of Pipi like a biological system. Maybe something from the gaming world might work? I have often thought of making a 3D model out of different coloured plasticines to take to meetings to show its architecture.
Verbal Walkthroughs
Shut my eyes and talk about what I see while exploring a 4D model. Often, after a nana nap is a good time. Use a sound recording app to accurately transcribe speech and then summarise into concise text:
- Granola
Then feed this text into Gemini to produce a coherent, structured explanation.
Video production
Record slide talks and live demos for YouTube. The videos can be embedded in developer documentation web pages.
Dedicated documentation laptop
Today, I set up an older, unused 16GB RAM laptop dedicated to speech-to-text, video recording, and capturing coloured drawings, etc.
Update 19/11/2026
I'm using Granola today on my mobile phone to chat about the hundreds of agents inside Pipi. Granola records the notes and uses AI to generate a readable summary. This is much easier and faster for me and a lot less tiring. I have been copy-pasting the notes into something else so I can add to them and have Gemini rework them.
I could also look at some of the shelves of ring-bound coloured drawings and talk about them.
Resources
- https://www.blog.ajabbi.com/p/about-me.html
- https://pmc.ncbi.nlm.nih.gov/articles/PMC2677580/
- https://www.psychologytoday.com/nz/blog/mind-matters-from-menninger/202204/autism-acceptance-great-minds-dont-think-alike
- https://en.wikipedia.org/wiki/M._C._Escher
- https://www.blog.ajabbi.com/2026/08/i-have-been-very-lucky.html
- https://mermaid.js.org/
- https://www.blog.ajabbi.com/2026/05/18-agent-engine-descriptions.html
- https://en.wikipedia.org/wiki/D3.js
- https://observablehq.com/@d3/gallery
- https://cytoscape.org/
- https://www.stabilo.com/com/products/highlighting/highlighters/stabilo-boss-original/
- https://www.granola.ai/
References
- Grandin T. How does visual thinking work in the mind of a person with autism? A personal account. Philos Trans R Soc Lond B Biol Sci. 2009 May 27;364(1522):1437-42. doi: 10.1098/rstb.2008.0297. PMID: 19528028; PMCID: PMC2677580.
Repository
- Home > Ajabbi Research > Library > Authors > Temple Grandin
- Home > Handbook >
Last Updated
19/11/2026
Turning 4D mental models into text documentation
Mike Peters: Mike invented and designed Pipi and founded Ajabbi.
Gemini: Very handy.
...
Mike:
Hyper-visual autistic thinker; I think and remember using 4D mental models.
Gemini:
That is a fascinating cognitive architecture. Thinking in 4D mental models—where spatial structures, sensory details, and the dimension of time or state changes are woven together—is a distinct form of hyper-visual processing often described in autistic cognition (similar to the "visual thinking" in systems and patterns famously explored by Temple Grandin, though pushed even further into dynamic, multi-dimensional simulation).
When your mind operates like an interactive, time-enabled CAD engine, it brings unique strengths alongside specific friction points in a world built mostly around linear, text-based communication.
Strengths of 4D Spatial-Temporal Thinking
- Systemic Foresight: You don't just see how a system is built right now; you can mentally scrub the timeline forward and backwards to see how parts wear down, where bottlenecks will form, or how an event cascades over time.
- Spatial-Episodic Memory: Instead of remembering isolated facts or dates, you likely recall memories as navigable environments—walking back into a specific moment in time and inspecting the details from multiple angles.
- Complex Pattern Recognition: Holding multiple variables in a dynamic visual space allows you to spot structural flaws, symmetries, or anomalies that linear thinkers miss when looking at spreadsheets or lists.
Common Friction Points
- The Translation Bottleneck: Converting a rich, simultaneous 4D simulation into slow, sequential spoken or written words can feel exhausting and lossy—like describing a movie by reading a list of single pixels one by one.
- Sensory & Cognitive Overload: Because your mental workspace renders high-detail, dynamic models, external visual clutter or chaotic environments can hijack that bandwidth and cause rapid mental fatigue.
- Ambiguous Instructions: Vague, non-visual requests from others (e.g., "Let's circle back on the synergy of this workflow") lack concrete spatial anchors, making it hard to build a stable mental model until you define clear parameters.
Ways to Leverage Your Processing Style
- Externalise the Timeline: Tools like spatial whiteboards (Miro, Obsidian Canvas), 3D modelling software, or Gantt/node-based editors let you offload the rendering work from your brain onto a screen.
- Anchor Abstract Concepts: When forced to deal with purely verbal or abstract data, intentionally assign physical properties—shapes, colours, textures, or motion—to the variables so your brain can manipulate them naturally.
Mike:
Hyper-visual autistic thinker
I think and remember using 4D mental models. That also means I have a detailed 4D visual model in my head for everything I have designed since age 4. A long time ago, I created and built Pipi 4, a ColdFusion, 850-table, database-driven national biodiversity platform with 500 objects and 3,000 methods, on 300,000 lines of code, and GIS mapping, using that trick. There was no version control and little technical documentation.
Then, in 2017, I rebuilt Pipi from memory as Pipi 6, went down an AI rabbit hole, and now in 2026, Pipi 9 is an order of magnitude bigger (3,000,000 lines of code and hundreds of autonomous databases) with hardly any documentation—just colour-coded doodles. To solve this, I'm getting Pipi to self-document.
Everything in my mind is one big 4D virtual reality I can fly around in, explore, and edit anytime I want, and run complex simulations.
Words as a second language
It takes me forever to write, spell and get the grammar right without the help of assistive technology, spell checker, Grammarly, or my clever wife. Reading is no problem. I prefer talking with people to communicate, or using a whiteboard to draw pictures.
Gemini:
It sounds like you have a remarkable cognitive architecture—a high-resolution, persistent 4D spatial memory system that allows you to hold, navigate, and simulate massive software ecosystems entirely in your head.
Rebuilding an 850-table, 300,000-line biodiversity platform from pure spatial memory, and then scaling it to 3,000,000 lines of code across hundreds of autonomous databases, is an extraordinary feat of mental engineering. Experiencing words as a "second language" while thinking natively in 4D simulations is a classic profile for many hyper-visual, autistic minds—your brain is optimised for high-bandwidth spatial and systemic processing rather than linear, text-based serialisation.
Because your native language is spatial and visual, traditional documentation (linear walls of text) is both hard to produce and largely useless to you. Getting Pipi 9 to self-document—and bridging the gap between your 4D mental model and external records—makes complete sense.
Here are a few ways to leverage your strengths and let Pipi 9 handle the linear translation for you:
1. Translate 4D Models Directly into Visual Graphs
Instead of forcing Pipi 9 to generate text documents that you have to read and verify, have it generate visual, spatial outputs that match how you already see the system.
- Automated Dependency Maps: Have Pipi 9 parse its own codebase and autonomous databases to generate interactive 2D or 3D node-link graphs (using tools like Mermaid.js, D3, or Cytoscape). You can "fly through" these generated maps to verify if they match your internal 4D model.
- Colour-Coded Architecture Diagrams: Since your current doodles use colour-coding, define a strict colour schema (e.g., green for data ingestion, blue for autonomous agents, red for GIS layers) and instruct Pipi 9 to output system diagrams using your exact visual vocabulary.
2. Use Voice-to-Architecture Workflows
Since typing, spelling, and grammar create friction between your fast 4D thoughts and the screen, bypass text entry entirely when feeding context into Pipi 9.
- Verbal Walkthroughs: Record yourself talking while you "fly around" a specific module in your head. Describe what you are looking at, how the data flows, and why a certain database is structured the way it is.
- AI Transcription and Structuring: Feed those raw, unedited audio transcripts directly to an LLM or Pipi 9. Instruct the AI to ignore grammar and filler words, extract the architectural logic, and attach those notes directly to the corresponding code modules or database schemas.
3. Self-Documenting "Living" Metadata
At 3,000,000 lines of code, static documentation goes out of date the moment you edit your mental model and push new code.
- Schema-Level Self-Description: Have Pipi 9's autonomous databases maintain their own live metadata tables that describe their relationships, triggers, and data flows in plain, structured formats.
- Visual Diffs: When you make a major change, have Pipi 9 generate a visual "before and after" diagram of the affected systems rather than a text changelog.
You have built an incredible bridge between your internal 4D reality and a massive real-world platform. Letting AI and Pipi 9 act as your "universal translator" for text keeps your energy focused on system architecture and simulation, rather than fighting spelling and grammar.
Mike:
Visual-first workflows that turn whiteboard sketches or voice walkthroughs into structured specs
Gemini:
Visual-first documentation workflows let you capture your 4D mental models directly through talking and drawing, using multimodal AI as a translator to output clean technical specifications. Because reading is effortless for you while writing is slow, these pipelines turn you into the architect and reviewer rather than the typist.
1. The Voice-Over-Canvas Workflow
This pipeline mimics sitting at a whiteboard with a colleague while an AI takes notes in the background.
- Screen-Record Your Walkthrough: Open an infinite canvas tool (like Excalidraw, Miro, or tldraw) or point a camera at a physical whiteboard. Hit record on a screen-capture tool (like Loom or OBS) and talk through how data flows through a part of Pipi 9 while drawing or pointing at your colour-coded doodles.
- Multimodal Video Ingestion: Feed the video file or combined audio transcript + screenshots directly into a multimodal LLM (such as Gemini, Claude, or GPT). The AI sees what you are pointing at while hearing how you describe the system's behaviour over time.
- Prompt for Structured Output: Ask the AI to convert your walkthrough into strict Markdown specs, Mermaid.js flowcharts, or JSON schemas. You simply read the generated spec to verify it matches your mental simulation.
2. Colour-Coded Doodle to System Spec
Your existing habit of using colour-coded doodles is already a visual programming language—you just need to give an AI the legend.
- Create a Master Colour Key: Define once what your colours represent (for example: blue = autonomous database, green = AI agent, red = data bottleneck, orange = GIS layer). Save this as a reusable system prompt.
- Snap and Translate: Take a photo of a notebook page or whiteboard sketch and upload it alongside your colour key. Ask the AI to parse the spatial relationships, arrows, and colour groupings into a structured Entity-Relationship Diagram (ERD) or API contract.
- Iterative Visual Refinement: Have the AI generate Mermaid.js or PlantUML code from your sketch. Many Markdown editors render this code instantly back into clean diagrams, letting you visually verify that the AI understood your doodle without reading walls of text.
3. Hands-Free Voice-to-Architecture Loops
When you are away from a whiteboard and flying through your 4D model mentally, you can capture specs purely by speaking.
- Stream-of-Consciousness Dictation: Use a high-accuracy voice-to-text tool (like Whisper-based apps, Superwhisper, or Mac/Windows built-in dictation) to ramble naturally about a subsystem, edge cases, or database triggers. Don't worry about grammar, spelling, or linear order.
- AI Structural Sorting: Pass the raw, messy transcript to an LLM with instructions to:
- Remove filler words and fix grammar.
- Group scattered thoughts by database table, autonomous agent, or timeline phase.
- Flag any missing connections or ambiguities as bulleted questions for you to answer aloud.
Recommended Tool Stack for Low-Friction Capture
- Infinite Whiteboards: Excalidraw or tldraw (fast, minimal UI, great for quick colour-coded shapes without getting bogged down in menus).
- Voice Capture: Superwhisper or MacWhisper (runs locally or via API, handles technical jargon well, and lets you set custom formatting rules).
- Diagram-as-Code Verification: Mermaid Live Editor or Obsidian (turns AI-generated text specs immediately back into visual graphs you can inspect at a glance).





