Kinds / Canonical
explorations/
Thinking out loud where the destination is unclear, until a spec is possible.
126 files · 19 projects
augment-itai-labs30
The Gap Between What We Preach and What We Practiced
Forty deployable units, one git repo, zero component-level design systems or changelogs. An honest audit of augment-it against the three recommendations we make to clients.
Design Language Audit — July 2026
The hand-counted baseline audit that measured the state of augment-it's CSS before the design system shipped. Superseded as the counting mechanism by design-drift.mjs.
Augment from DB — the org-first workbench flow, and the two new microfrontends it needs
A flow that starts from SurrealDB, not a CSV: pick an org, reveal its people and pulse streams, augment through pluggable search packs.
augment-it has outgrown one flow — ROTATION is the CSV-augmentation pipeline's shape wearing a general-purpose name, and corpora-curator's promotion to its head is a splice, not a fit
ROTATION (`shell/src/remotes.ts`) is the CSV-augmentation flow hardcoded as THE nav — every other use case gets spliced onto it.
Syncthing for Collaborator Access to the Corpus (R2 Backup Already Decided)
R2 already won the backup leg — rclone, not a live mount. This is the separate, still-open question: could Syncthing give other humans live access to the same corpus, without breaking the single-writer discipline that's kept things sane so far?
The Moat Is Grounded Deliverable Production, Not Chat
Chat-over-documents is commoditizing; the moat is the last mile — a shippable deck or memo with every claim traceable to source.
Funder-Fit Engine — Org-Anchored Corpora and the Bidirectional Story↔Funder Cycle
Fundraising matches both ways — funder→story and story→funder — on one org-anchored corpus. The differentiator is KAG, not plain RAG.
Forced One-By-One Tag Selector — a pulse-dimension pattern for deliberate triage instead of lazy bulk-tick
Bulk checkboxes produce uniform half-considered tags. Present one tag at a time — apply / skip / skip-rest — and each decision gets made.
Joined People UI and the Network-First Pivot — augment-it's sibling-flow to org-first augmentation, and the canonical/proprietary layer split underneath it
Org-first and people-first are two pivots on one join — and the split that matters is canonical (shareable) vs proprietary (client-only).
Best Way to RAG Over the Corpus — design space for retrieval-augmented operations on augment-it's per-client corpus, given the structured frontmatter we just earned
245 corpus files carry `funder_slug` and `published_at`, so retrieval is facet-filter-first — embeddings handle the residual about-ness.
Inbox Sort by Agent Tasks — moving the inbox from a flat 86-item pending queue into a task-typed work surface where the operator sees what's next and the agent does the safe parts automatically
86 pending inbox files render identically, so the operator context-switches between four task types on every scroll.
Operator-built flows beyond the universal pipeline — the default augmentation path is a dud for most edge cases, and the cheaper-than-microfrontend escape is a view-spec the agent-chat composes from natural language and the UI renders generically
The default flow lands cleanly on 17 of 96 reach-edu records. The escape isn't a microfrontend per scenario — it's a generic spec-renderer.
In-App Browser vs Browser Plugin for Corpus Add — bridging the operator's own search into the per-record corpus without leaving the cockpit
Adding one operator-found URL to a funder's corpus is a ten-step round-trip out to Google and back. In-app browser, or browser plugin?
Per-Client Privacy and the Path Off Local — when does single-operator-local-only stop scaling, what stack do we reach for, and how do we architect today so the move is cheap when it comes
Per-client corpus privacy and a client wanting login hit the same week. Not a stack decision — which choices keep the move off local cheap.
Agent-Chat Skills and Commands — Candidates List
The chat's verb roster is four prompt-focused capabilities. A running list of shell scripts that should graduate into chat-callable verbs.
Augment-It Prior Art Survey — What's Already Been Built, and What It Tells Us
Two prior attempts exist — Tanuj's three federated repos and Michael's bolt monolith. Both cover the core; neither is what we ship.
Bolt-Era API Provider Widget Analysis
The bolt widget picked Claude, GPT, or Perplexity per prompt section. The widget dies in the rewrite; the multi-provider shape stays.
Bolt-Era Codebase Analysis
A faithful architectural map of the bolt monolith — React + TS + Vite + Supabase + zustand — lifted from its own `specs/` folder.
Bolt-Era Highlight Collector Analysis
The only existing description of the highlight-collector stage — one of two that never got split into Tanuj's microfrontend repos.
Bolt-Era Main Container UI Analysis
The bolt shell's five-column layout and auth gate — prior art for the rewrite's open question: one host shell, or a host per app?
Bolt Monolith As Built — The archive/bolt-code Branch
The earliest augment-it is a Vite + React monolith on `archive/bolt-code`: feature-richer than the federated repos, architecture we discard.
Bolt-Era Prompt Section Analysis
Prompt templates as MDX-rich, variable-aware, edit-toggle-preview blocks — the pattern prompt-template-manager should probably adopt.
Bolt-Era Record Collector Analysis
Cross-reference against `Tanuj-Record-Collector-As-Built` — the diff between bolt-era and forked shows which patterns survived federation.
Entity-Profile Augmentation Workflow — Common Social + Vertical-Specific Sources, Per Entity Type
Two tiers replace prompt-by-prompt column filling: packs as atomic source-bound units, bundles as workflow-shaped compositions of packs.
Federation and Bundler Decision — Bun + Rsbuild + Module Federation, Workspace State, Optional Chat
We federate: Module Federation on rsbuild, bun over turbo, and state of truth in `@augment-it/workspace` — chat is just one consumer.
Tanuj's Prompt-Manager As Built
Full CRUD-shaped prompt UI over a hardcoded `samplePrompts` array — no store, no data flow. Keep the schema, throw away the implementation.
Tanuj's Record-Collector As Built
The most-finished of Tanuj's three splits. One idea survives: the prompt template auto-generates from the imported CSV's columns.
Tanuj's Request-Reviewer As Built — The Module Federation Proof
The only place Tanuj got federation working — a shared `RecordCard` — while the augmentation logic sits copy-pasted from record-collector.
Multi-Agent Research Fan-Out Per Row — The Real Shape of Augment-It's Capability Runtime
Capabilities aren't LLM calls — five research agents run per row in parallel, so the runtime needs (rows × agents) fan-out.
augment-it/explorations
ai-labs16
A Syncbox for Client Document Folders — Where Does History Actually Live?
The ask is one product. The prior art says it's three layers, and nothing on the shelf does all three on a bucket.
didi.sh — One Login, One Agent, Three Services
memos, decks, and augment-it become one family coordinated by exactly two shared planes: a common identity service and one agent named didi. Consumer one is live; the local-auth question is now closed.
When Claud Code and When Pi
Secrets for Collaborators Who Will Never Open a Terminal
Collaborators who will never open a terminal still carry API keys — so serve capabilities from a remote MCP plane, secrets held server-side.
Cross-Product Native Agent Shell — Synthesis and Architecture Decision
Resolves the fork the in-app-agent docs left open — extend memopop-native or build standalone — against sixteen pinned repos' actual source.
In-App Agent Chat — As-Built vs. As-Specced (Internal Audit)
`@lossless/in-app-agent` was never built — augment-it inlined the WorkspaceAdapter pattern into `@augment-it/workspace` instead.
Shared Auth for Applied AI Labs
Three sibling apps need login; none is at Auth0/Clerk scale. A small owned system: OAuth, invites, org-scoped roles, a roll-up seam.
Two Clients, One Flow — Corpora by Domain-Type, Auth, and Deployment Converge
reach-edu wants corpus→memos by strategy, humain-vc by thesis — and typed domains, shared auth, and deployment all came due at once.
Corpus-Grounded Generation — Memory & Graph Layers for Producing Decks and Memos Without Drift
A pipeline where every factual sentence in a deck or memo traces to a source span — and the model abstains when it can't.
Cloud Variant of the Dididecks-AI Workspace — Recreating Local Privacy When the Filesystem Isn't Yours
Clients who won't install a desktop app still need the privacy local-fs gives for free. What a cloud runtime would have to do explicitly.
Memory Layers for the In-App Chat Package
Maps the eight pinned memory systems onto roles in the chat package, and picks the v1 stack given we already lean on Chroma.
Remote Mount Contract for @lossless/in-app-agent — How the Chat Surface Drives Federated Views Without Owning State
How the chat surface drives federated views without owning state: capability invocation goes through the per-app workspace, never the chat.
In-App Chat as the Agent Surface for Client Apps
Rather than design a button for every client request, wire one chat surface loaded with our patterns and context. The chat is the menu.
ChromaDB as Context Improvement Across Everything, Everyone
A founding-team demo reframed Chroma: not a place to put embeddings, but an ingestion layer for agent traces and session transcripts.
Collate Context Files into Context Vigilance as Repo & Project
A long-running, everywhere-distributed practice — context-v/ across a tree of pseudomonorepos — finally graduates into a project of its own, with a collator, a splash, and a vector index.
ai-labs/explorations
Lost in Public13
Enhance Visualizations with Use of Formats
lost-in-public/explorations/self-hosting-multi-site-analytics-platforms
Multi-Site Astro Starter Kit Architecture
Exploration of building a comprehensive Astro starter kit optimized for rapid deployment of multiple marketing sites with environment-driven customization
Foundational Workflow In The Terminal And Command Line
Accessing Figma through a Windsurf MCP Server
Interact with Figma Designs while building an application, straight from the IDE
Automating Content Generation With Local LLMs
Creating a Custom GPT with OpenAI
Exploring Model Context Protocol SDK
Tinker with the Model Context Protocol SDK created by Anthropic
Finding an Email Newsletter API that Supports Multiple Domains
Most email newsletter services boast the deliverability and the large number of emails. But what if you just need to send a limited number of emails but support multiple domains?
Using MCP Servers to Speed-up Astro Development
What kind of MCP Servers actually speed up Astro Development?
Creating A Flavored Syntax Parsed To UI
Using Obsidian To Manage Markdown Based Content Collections For Static Site Generation Frameworks
Using Test Coverage to Constrain AI Code Assistants
astro-knots11
AI Photo-to-Illustration Transform for Arthouse
Exploring how to take a real client photograph — sometimes NSFW-sensitive — and return an obviously AI-generated illustrative version (anime, painterly, or stylized) that is safe to publish on the public arthouse-site portfolio.
Rethinking Confidential Access with Persistent Sessions and Auth Telemetry
The calmstorm-decks lockout — busy client, no telemetry — exposed the passcode pattern's limit: you can't tell a failed cookie from a typo.
Converge on an Animations Playbook
Lottie the format is open; every tool that produces one is proprietary SaaS. A tiered motion playbook for Astro Knots given that lock-in.
Implementing Full-Text Search by Default
Every Astro Knots site should ship with full-text search out of the box. This is a tour of what that costs, why Pagefind (a Rust-powered static indexer) is the strong default, and what the runner-up libraries are for the cases where it isn't.
Practices to Sense-Make Context Vigilance at Scale
An exploration of lightweight conventions, indices, templates, and tooling that keep a context-v library legible as it grows from dozens to hundreds of documents — without introducing a new system to maintain.
Web Research Agents for Content Augmentation
Point an agent at a URL and have it fill out a tool's YAML frontmatter — and why most agent-framework hype is the wrong tool for that job.
Choosing an Image Generator for Text-on-Background Banners
An April 2026 snapshot of image generators judged on one job: release-banner images with legible title text and a consistent brand feel.
Exploring GitHub Actions for Package Publishing
A practical walkthrough of what GitHub Actions are, how they work, and how to use them to publish packages to JSR and GitHub Packages with provenance — written for someone who has never set up CI/CD before.
New Homebrew Formulae Worth Knowing About
A quick-hit survey of six new Homebrew formulae — dispenso, jsongrep, opentimestamps-client, proxelar, qtcanvaspainter, and qttasktree — with an honest assessment of what each does and whether our dev team should care.
Understanding the JavaScript Runtime and Package Manager Landscape
A ground-up exploration of what Node, Deno, Bun, npm, pnpm, Yarn, Vite, tsup, and esbuild actually are, why they exist, how they relate to each other, and when to use which — because the JavaScript ecosystem never explains itself.
astro-knots/explorations
self-host-stack9
Watchlist — Interesting Tools Not Yet Sorted
A running catch-all for tools worth a second look, before we know whether they map to a self-host-stack category, a personal-workstation list, or nothing at all.
Aggregating Historical Calendar Items for Lossless Twenty
Started as 'should we deploy cal.diy' and ended somewhere else entirely — cal.diy deletes the past by design, Twenty's importer already backfills everything, and the thing actually worth building is a one-time ICS backfill that never touches OAuth.
Do we need a sandbox behind homebase?
Homebase federates tools but stores nothing and runs nothing. The missing piece turns out to be two pieces — storage, which is already funded, and compute, which can wait.
Replacing Granola with an Open-Source Transcription Stack
Transcription is solved and free. Knowing who was speaking is neither — and it's the half that makes a meeting-notes product feel good.
Per-Client Self-Host Stacks, Twenty-First, on Railway
One playbook, three tiers: managed client stacks on Railway, a hub page clients actually use, and a per-client remote MCP server that could grow into a full context plane.
Should Hermes Agent Co-Locate on the Same Host as TwentyCRM?
Colocation feels like it should mean 'automatic access' — the evidence says it doesn't, and the real value is elsewhere.
Sharing One Hermes Agent Instance Across a 3-Person Client Team
Hermes Agent has no shipped multi-user mode — the gap is real, catalogued, and still open upstream.
An Instantly-Synced Shared Folder for a 3-Person Team
Nextcloud was the first name that came to mind — but the actual ask is pure instant file sync, and that's a different tool's specialty.
self-host-stack/explorations
memopop-aiai-labs8
MemoPop as a Claude Connector
Clients won't open our app. They'll ask Claude, and Claude will reach their deals, sources, and memo history through a connector.
Grill Me: A Per-Section User-Input Moment in MemoPop Runs
A pause-point where MemoPop grills the user — the competitive section's synthesis frame is a judgment the model shouldn't make alone.
Curating Only Valid Sources Across Runs
Downstream curation cannot fix what `citation_enrichment.py` invents upstream — 65 fabricated `example.com` URLs in a single run.
Human-Curated Source Sets and Per-Firm RAG for Memo Narrative
Keep Perplexity's take as quarantined commentary and route real research through validated harvesters plus a per-firm standing RAG store.
Separating Retrieval from Generation in Agent Pipelines
An agent that both searches the web and writes the prose fabricates URLs — 65 `example.com` links in a single memo run.
Crawl for Better Team Structured Output
The orchestrator writes prose about teams but never returns the structured roster the app needs to render cards: names, titles, photo URLs.
Moving an Agent Orchestrator to an API
The orchestrator is a Python CLI today. To plug it into memopop-native, we need an HTTP-shaped surface. Three options, ranked by effort and time-to-value.
memopop-ai/explorations
content-farm6
Enabling Obsidian Plugins to Access Homegrown API Helpers
Architecture patterns for bridging Obsidian's JavaScript environment to powerful, non-JS backend logic (Python, Rust, CLI tools) via lightweight cloud proxies.
Moving Beyond Simple API Calls — LLM Orchestration Options for Our Plugins
Locks the `cf` codefence grammar and holds the line on direct vendor SDKs — Vercel AI SDK if we outgrow them, never LangChain.
Self-Hosting the Vault via Ignis — Team-Wide Browser Access to Content Farm
content-farm's whole plugin set assumes desktop Obsidian. Ignis runs Obsidian in a browser against a server-side vault — worth knowing about, not yet worth committing to.
Citation Resolution and the Canonical Source
Link-rot recovery, lookup-before-create on save, and content preservation for RAG are three operations on one underlying entity.
Using APIs to Ingest More Data
Beyond OpenGraph.io — what Jina.ai already gives us (we pay for it), what other fetching services do, and a rough sketch of how a portfolio-company site crawler would actually work.
content-farm/explorations
lossless-monorepo5
Syncing Directories Across a Pseudomonorepo
Three annoyances that look like one problem. Symlinks break git, submodules cost too much, and rclone has no watcher.
VC Self-Host Stack as a Pseudomonorepo (and a Paired Study)
Two orphan dirs, `twenty-crm/` and `twenty-deployment/`, hint at a deployable stack a VC firm could self-host instead of renting SaaS.
Explore: GitHub API for Live KPIs — Credibility Without Stars
60+ commits/day per person, 4,400+ content files, no 50K stars. What GitHub can give us for a credibility-by-shipping story.
Explore: Using PRs More — Why a Solo Dev Should Bother
PRs aren't a review ritual — they're an integration ritual: squash a granular trail into one shipped unit with a stable URL and a CI gate.
lossless-monorepo/explorations
studiesai-labs4
Create Study Everything as Code
Study Kickoff — Content Authoring Tools
Explore Collaborator Codebases for Insights — Comparative Highlights
When a friend has built their own agentic-coding silo next to ours, compare the silos both ways: what we can learn from them, and what they can learn from us.
studies/explorations
context-vigilance-kitai-labs3
Context-V as a Portable Plugin Any Agent Can Install
A human pastes one line, and their agent does the rest. The last mile of the cv plugin is an install contract written for agents, with Claude Code as the first harness, not the only one.
Context-V as a Claude Code Plugin
The conventions are good and the agent still forgets them. A plugin turns context-v's workflows into commands and its frontmatter into queries — so a loop's preconditions get checked instead of remembered.
context-vigilance-kit/explorations
corpora-builderai-labs3
Corpora-Builder System Design
Corpus building has been rebuilt as a sub-feature three times across ai-labs. This exploration surveys what those iterations actually taught us, and sketches the system that deserves its own repo.
Design Front-Loading and the Fable Build Loop
If frontier models can now carry complex builds end-to-end, the leverage moves to the documents. Can we front-load design so hard that the whole system gets built in a TDD loop — and impose design-system discipline from commit one?
corpora-builder/explorations
reach-edu-hubai-labs / dididecks-ai3
Deck Collections — a menu/aggregation layer above single-deck convergence
Everything dididecks has built so far (calmstorm, chroma) operates inside ONE deck: converging on a single narrative through variants and versions. reach-edu-hub needs the layer above that — a curated menu of several DISTINCT decks, each its own narrative (a 'strategy'). This doc names that layer 'deck collections', fixes the conceptual model (a collection groups peer decks; a variant is an alternate design of the same deck — different axis entirely), specifies the near-term reach instantiation (a Strategies collection of ~5, possibly more, decks), codifies the per-deck authoring loop (LLM-authored narrative markdown → Claude designs the deck Scroll-UI-first → register → drop into the existing dididecks variant/version workflow only if needed), and proposes how the concept graduates into the shared @dididecks/shell so it's reusable across client-sites.
Exporting the Strategy Decks to Google Slides
The seven strategy decks live as code — Astro Scroll-UI sections, not slides in any format Google Slides understands. Getting them into Slides for a stakeholder who wants to open, present, or lightly edit them in the tool she already knows is a real pipeline question, not a five-minute export. This names the actual path: what format has to exist first, what's proven prior art from calmstorm-decks, and what reach-edu-hub is missing today to make it clean.
reach-edu-hub/explorations
id-didi-shai-labs3
What Corpora-Builder Needs From didi.sh — the primitives list, handed over early
corpora-builder wants workspace identity from didi.sh. Two gaps: workspaces aren't a thing here yet, and a CLI has nowhere to put a cookie.
Serving Secrets Server-Side as an MCP Capability Plane
Implementation-local notes on a remote MCP endpoint that holds credentials server-side and hands collaborators capabilities, not secrets.
id-didi-sh/explorations
context-v-corpus3
Graphiti Over the Lossless Corpus
Chroma cannot answer "what changed, and when." Graphiti's bi-temporal graph can — pointed at the changelog rollup until the bet proves out.
Code-Comment Sections as Context-V Source
JSDoc made code comments the source of truth for API docs. Could section-level comment blocks be the source of truth for context-v entries?
context-v-corpus/explorations
site3
Abandoned Intention — The Tube Visual (four-layer branded container)
A retired attempt at a signature 'tube box' framing device — four concentric layered borders wrapping content — explored across three rendering strategies (CSS clip-path, raw SVG, Webkit) and never adopted. Captured here so the design intent survives the code being dropped in the site-next rebuild.
Rethink on Client-Focused Landing Pages
Three overlapping mechanisms — `for_clients` frontmatter, MOC files, and the `client-content/` tree — are trying to do the same job and stepping on each other. This is a thinking-out-loud document, not a spec.
site/explorations
flave-aiai-labs2
The MVP Delta, and What 'A Version Per Audience' Actually Requires
The editor half of the MVP is mostly built. The half that is the product, one document published to several audiences with proof that nothing leaked, has no code yet, two underspecified mechanisms, and one syntax in the spec that does not parse.
flave-ai/explorations
perplexedcontent-farm2
Multi-Stage Cooperative Claude + Perplexity with RAG
What if a market-map draft were the output of three agents — a RAG pre-flight that names what to include, a Perplexity research run that finds the rest, and a Claude editorial pass that never steps on either — instead of one single-shot prompt?
perplexed/explorations