savant-code 0.0.17 → 0.0.19

package/docs/OpenTUI Sidebar Bug Fix.md

@@ -0,0 +1,245 @@
+# **Root-Cause Analysis and Remediation of OpenTUI Sidebar Row-Highlight Anomalies**
+
+## **1\. OpenTUI Rendering Architecture and Pointer Event Propagation**
+
+To understand the persistent row-highlight anomaly within the Savant-Code CLI sidebar, one must fundamentally
+examine the architectural convergence of the OpenTUI layout engine, the React reconciler, and the native terminal
+pointer event pipeline. OpenTUI operates by translating declarative component trees into a flat, double-buffered
+cell array, known as the FrameBuffer or TextBufferView, utilizing a native Zig core for alpha blending, true color
+rendering, and terminal cell compositing1. Within this environment, visual layout is computed using Yoga, a
+cross-platform flexbox engine that maps CSS-like spatial properties onto a rigid 2D terminal character grid.
+When a user interacts with the terminal via a mouse click, the terminal emulator captures the interaction and
+translates it into standard escape sequences, typically following the SGR 1006 protocol for extended mouse
+tracking. The OpenTUI native core intercepts these sequences and decodes the exact column and row coordinates. This
+raw hardware event is then passed across the foreign function interface (FFI) into the TypeScript runtime, where it
+is instantiated as a synthetic MouseDown event2. The framework then initiates a hit-testing phase against the
+Yoga-calculated bounding boxes of the currently mounted Renderable nodes.
+Hit-testing in OpenTUI operates recursively from the root CliRenderer down to the deepest intersecting child node.
+Once the deepest node is identified, the event is dispatched to that specific Renderable via the processMouseEvent
+lifecycle method2. At this exact juncture, OpenTUI implements an event-bubbling architecture mirroring the standard
+Web DOM specification. If the target node possesses an event handler that consumes the event—specifically by
+invoking event.stopPropagation()—the propagation halts immediately3. If the target node does not handle the event,
+or if it lacks an explicit event sink, the event systematically bubbles up the ancestral chain, testing each parent
+container for a corresponding handler.
+If a MouseDown event traverses the entire ancestral chain and reaches the root CliRenderer without being
+intercepted or having its default action prevented, the global event orchestrator assumes the interaction was
+directed at the underlying text buffer rather than a distinct interactive component. Consequently, the renderer
+activates the global selection engine, initiating a drag-to-highlight state originating from the clicked cell
+coordinates5. It is this precise fallback mechanism that generates the unintended visual highlighting observed in
+the application.
+
+## **2\. Root Cause Analysis**
+
+The root cause of the sidebar row-highlight bug is an event propagation leak stemming from a structural
+misalignment between the Yoga flexbox layout and the localized event handlers within the React component tree. The
+recent refactoring of the right sidebar from static ASCII box drawing to native OpenTUI flexbox components
+inadvertently exposed layout-synthesized whitespace to the global selection engine.
+An analysis of the RightSidebar.tsx source code reveals that the root container allocates a strict, fixed-width
+layout constraint using width={40} and flexDirection="column". This forces the Yoga engine to explicitly reserve a
+40-character wide column on the right side of the terminal display. Nested within this container are multiple
+SidebarSection primitives, which in turn encapsulate interactive elements such as FidCard.
+The critical flaw was introduced during the optimization of the SidebarSection component's hit area. The
+onMouseDown handler, responsible for toggling the expanded state of the section, was applied to an inner \<box\>
+component configured with alignSelf="flex-start". The alignSelf="flex-start" property instructs the Yoga engine to
+shrink the bounding box of that specific container to match the exact dimensions of its inner content—in this case,
+the toggle chevron text and the section title text.
+While this correctly restricts the interactive toggle hitbox to the visible text, it leaves the remainder of the
+40-character width completely devoid of event listeners. The parent \<box flexDirection="column"\> surrounding the
+toggle row fills the remaining horizontal space with empty cells generated by the layout engine. When a user clicks
+in this empty space to the right of a sidebar title, the SGR 1006 sequence triggers a MouseDown event targeting the
+parent column box. Because this parent box has no onMouseDown handler to invoke stopPropagation(), the event freely
+bubbles out of the SidebarSection, out of the RightSidebar, and straight to the root CliRenderer. The root renderer
+intercepts the unhandled click, activates the global selection mechanism, and applies the high-contrast selection
+background styling to the empty cells, creating the visual symptom of an entire row becoming highlighted6.
+
+## **3\. The Failure of selectable and focusable Properties**
+
+The exhaustive application of selectable={false} and focusable={false} to every \<box\> and \<text\> element in the
+sidebar failed to resolve the issue because these properties govern entirely disparate subsystems within the
+OpenTUI architecture, neither of which interact with pointer event bubbling.
+The OpenTUI architecture strictly separates keyboard navigation scoping from pointer event sinks. The focusable
+property is tightly coupled to the FocusScopeRenderable lifecycle3. When focusable is enabled on a component, the
+framework registers that node within the internal focus graph, allowing it to participate in sequential Tab and
+Shift+Tab traversal, and enabling it to capture keyboard events via processKeyEvent4. Setting focusable={false}
+successfully removes the sidebar components from the tab-index array and prevents the rendering of visual focus
+indicators, but it exercises absolutely zero authority over the processMouseEvent pipeline. The pointer event
+system remains entirely oblivious to the focusable state of a container.
+Similarly, the selectable property dictates localized text extraction boundaries, not event propagation. When an
+element such as an ASCIIFontRenderable or TextNodeRenderable is marked with selectable={false}, the local component
+state instructs the renderer to reject targeted text-copy operations directly against that specific node5. However,
+the empty flexbox space triggering the bug is not a text node; it is structurally empty padding synthesized by the
+layout algorithm. When the unhandled click reaches the root, the global selection engine operates on the composited
+FrameBuffer cell array1. The global selection algorithm scans the raw cells, identifies them as empty buffer space,
+and highlights them indiscriminately. Because the event bypassed the component boundaries due to the lack of a
+propagation stop, the local selectable={false} flags on adjacent text nodes are never evaluated by the selection
+engine. The framework essentially treats the empty sidebar space identically to empty whitespace at the end of a
+standard text editor line.
+
+## **4\. Comparable Implementations and Ecosystem Patterns**
+
+An examination of mature OpenTUI-based applications, specifically the opencode-ai/opencode repository and
+established UI primitive libraries, demonstrates standard patterns for managing event boundaries in layered or
+constrained layouts. The terminal environment lacks a traditional \<body\> element to implicitly absorb stray
+clicks, necessitating explicit event sinks when defining boundaries that should not trigger global text selection.
+In implementations of floating menus, such as the OpenTUI Dropdown component, the architecture explicitly manages
+both click-inside and click-outside detections to prevent event leakage7. The Dropdown primitive binds onMouseDown
+handlers directly to its root floating container, ensuring that any click falling within its bounding box is
+captured, processed, and destroyed via stopPropagation(). This pattern prevents clicks intended for the dropdown
+background from bleeding through to the underlying syntax-highlighted code editor, which would otherwise trigger
+unintended text selections or cursor movements.
+Furthermore, within the primary layout grids of complex TUI applications, modal overlays and persistent sidebars
+consistently implement boundary sinks. When applications implement multi-view dashboards or split-pane interfaces
+(such as a CLI render mode with an interactive TUI at the bottom and a scrollback stream at the top), the boundary
+containers wrapping interactive widgets enforce strict event containment8. In the specific case of the Savant-Code
+CLI sidebar, the absence of an event sink at the RightSidebar container boundary represents a deviation from these
+established patterns, allowing the localized structural layout optimization (flex-start) to inadvertently
+compromise the global state machine.
+
+## **5\. Failure Modes and Edge Cases Assessment**
+
+When diagnosing unintended visual highlighting in a terminal user interface, it is imperative to distinguish
+between application-level rendering artifacts and hardware-level terminal emulator interventions. Terminal
+emulators such as iTerm2, Kitty, or Alacritty maintain their own selection buffers (such as the Linux PRIMARY
+selection or standard clipboard)9. Users can typically bypass the application's internal mouse protocol by holding
+a modifier key (e.g., Shift or Option) while dragging the mouse. This action temporarily suspends the application's
+receipt of SGR 1006 sequences, allowing the emulator to directly highlight the rendered text characters on the
+screen.
+If the row highlight in the sidebar were caused by a terminal emulator override, the visual styling of the
+highlight would match the native operating system or terminal theme, and the application's internal state would
+remain completely unaware of the interaction. However, the reported anomaly consistently utilizes the high-contrast
+selection colors native to OpenTUI's Selection class6, confirming that the phenomenon is driven by the internal
+React reconciler and Zig core.
+A secondary failure mode involves the potential for typeId indexing errors during rapid layout thrashing. When
+OpenTUI elements are frequently attached and detached, edge cases have been documented where internal renderable
+IDs desynchronize, causing pointer events to map to stale or destroyed parent nodes10. While defensive checks exist
+in the reconciler to safely ignore operations targeting destroyed parents, a click registering against a stale
+bounding box could theoretically misroute the event. However, the deterministic reproducibility of this sidebar
+bug—occurring consistently on static, fully mounted empty space—rules out transient reconciliation races and
+solidifies the diagnosis of a permanent event propagation leak.
+
+## **6\. Alternative Fixes and Tradeoff Analysis**
+
+Several strategies exist for remediating the event propagation leak, each carrying distinct architectural and
+user-experience implications for the application.
+
+| Remediation Strategy | Implementation Mechanics | Architectural Tradeoffs | Risk Assessment |
+| :---- | :---- | :---- | :---- |
+| **Root Boundary Event Sink** (Recommended) | Bind a generic onMouseDown handler to the outermost \<box\> in RightSidebar.tsx that explicitly invokes event.stopPropagation() and event.preventDefault(). | Enforces strict encapsulation. Safely isolates the entire sidebar from the global selection engine while preserving the optimized flex-start toggle hitboxes of child components. | **Negligible Risk.** Standard pattern for UI boundary enforcement. Does not interfere with interactions in the primary chat viewport. |
+| **Reverting to Full-Width Handlers** | Remove the alignSelf="flex-start" property from the inner \<box\> of all sidebar primitives, returning the onMouseDown trigger to the full 40-character layout block. | Relies on the functional UI handlers to implicitly consume the events. Eliminates the empty space by expanding the interactive zones to fill the layout. | **Moderate UX Risk.** Violates interaction expectations. Clicking empty space far from a text label will unintentionally trigger state changes (e.g., expanding or collapsing an FID card). |
+| **Global Selection Deactivation** | Alter the root renderer configuration via createCliRenderer({ useMouse: false }) or disable the root Selection service entirely. | Completely disables OpenTUI's internal handling of mouse interactions, offloading all selection capabilities strictly to the terminal emulator's OS-level fallback. | **Severe Feature Degradation.** Permanently breaks intended application-level interactions, such as drag-to-copy source code blocks within the main chat interface12. |
+| **Component-Level Primitive Sinks** | Add individual onMouseDown={(e) \=\> e.stopPropagation()} sinks to the parent \<box flexDirection="column"\> of every primitive (e.g., SidebarSection, FidCard, AgentStack). | Distributes the event stopping logic across multiple reusable components rather than centralizing it at the macro-layout level. | **High Maintenance Overhead.** Requires patching every existing and future primitive to ensure layout space does not leak events, increasing boilerplate and the likelihood of regressions. |
+
+## **7\. Recommended Implementation**
+
+The most robust and minimally invasive solution is the implementation of a boundary event sink at the root of the
+RightSidebar component. This directly addresses the propagation leak without altering the visual layout, degrading
+the precision of the inner hitboxes, or interfering with global behaviors outside the sidebar container.
+The required modification entails injecting an onMouseDown property into the outermost \<box\> element returned by
+the RightSidebar functional component. This handler will intercept any bubbling pointer event that was not consumed
+by a specific UI element (such as a toggle or a button) and cleanly terminate its propagation lifecycle.
+
+TypeScript  
+// Excerpt from RightSidebar.tsx demonstrating the applied fix
+
+export const RightSidebar \= React.memo(function RightSidebar({  
+  tokensUsed,  
+  tokensMax,  
+  cost,  
+  model,  
+  mode,  
+  agent,  
+  toolsUsed,  
+  toolsAvailable,  
+  filesChanged,  
+  agentStack,  
+  toolHistory,  
+}: RightSidebarProps) {  
+  const theme \= useTheme()  
+  const devMode \= useChatStore((s) \=\> s.devMode)  
+  const { fids: activeFids } \= useFids()  
+  const displayModel \= IS\_SAVANT\_FREE  
+    ? useSavantFreeModelStore.getState().selectedModel  
+    : loadSavantCodeModelPreference() ?? model  
+  const fids \= activeFids
+
+  return (  
+    \<box  
+      flexDirection="column"  
+      width={40}  
+      flexShrink={0}  
+      paddingTop={1}  
+      paddingBottom={1}  
+      paddingLeft={1}  
+      paddingRight={1}  
+      gap={1}  
+      focusable={false}  
+      selectable={false}  
+      // Binds a propagation sink to the sidebar boundary.  
+      // This intercepts all clicks originating in layout-generated empty space  
+      // and destroys them before they reach the global Selection engine.  
+      onMouseDown={(e: any) \=\> {  
+        if (e && typeof e.stopPropagation \=== 'function') {  
+          e.stopPropagation()  
+        }  
+      }}  
+    \>  
+      \<box  
+        flexDirection="column"  
+        alignItems="center"  
+        gap={1}  
+        paddingBottom={1}  
+        focusable={false}  
+        selectable={false}  
+      \>  
+        \<text attributes={TextAttributes.BOLD} fg={theme.primary} selectable={false}\>  
+          SAVANT  
+        \</text\>  
+        \<text fg={theme.muted} selectable={false}\>One Mind. A Thousand Faces.\</text\>  
+      \</box\>  
+        
+      {/\* Remainder of the component hierarchy remains unchanged \*/}
+
+By placing the sink on the 40-character wide parent container, any click landing to the right of the SidebarSection
+toggle buttons will immediately strike the parent padding/gap space, bubble up exactly one tier to the RightSidebar
+boundary, and be safely absorbed.
+
+## **8\. Verification Plan**
+
+Following the deployment of the boundary sink modification, a comprehensive verification matrix must be executed to
+ensure the event leak is fully sealed and that no unintended secondary effects have been introduced to the
+application's event routing.
+
+| Verification Phase | Execution Steps | Expected Outcome | Failure Indication |
+| :---- | :---- | :---- | :---- |
+| **1\. Precision Hitbox Confirmation** | Launch the application and click directly on the "▼ Tools" text or the accompanying chevron. | The section smoothly expands or collapses, demonstrating that targeted events are still firing successfully. | The section fails to respond, indicating the root sink was mistakenly configured as a capture-phase interceptor rather than a bubbling-phase sink. |
+| **2\. Event Leak Neutralization** | Position the cursor in the empty layout space horizontally adjacent to the "▼ Tools" text, but within the 40-character sidebar limit. Execute a single click. | The interface remains completely static. No UI element toggles, and no background selection artifacts appear. | A visual row highlight appears, or the section expands/collapses unnaturally. |
+| **3\. Drag-Selection Rejection** | Click and hold the mouse button within the empty sidebar space, dragging the cursor vertically across multiple sidebar components. | The mouse cursor moves normally, but no text or background space within the sidebar adopts a selection highlight color. | A continuous block of selection highlighting follows the cursor path, indicating the global drag engine is still engaging. |
+| **4\. Global Selection Integrity** | Transition the cursor into the primary left-hand chat viewport. Click and drag across a block of generative text or source code. | The text within the chat viewport highlights cleanly, confirming the global buffer selection engine remains fully functional for intended components. | Text fails to highlight, indicating the RightSidebar event sink has erroneously leaked its scope or global selection was inadvertently disabled. |
+| **5\. OS-Level Override Check** | Hold the terminal emulator's override modifier (e.g., Option on macOS or Shift on Linux) and click-drag across the sidebar. | The raw SGR sequences are bypassed, and the terminal emulator explicitly highlights the text using the native OS clipboard buffer theme. | The terminal emulator fails to capture the text, identifying an unrelated issue with SGR protocol configurations. |
+
+### **Works cited**
+
+> 1. GitHub \- Dicklesworthstone/opentui\_rust: Terminal UI rendering engine for Rust with real RGBA alpha
+  blending, scissor clipping, and double-buffered cell composition. Port of OpenTUI (Zig).,
+  [https://github.com/Dicklesworthstone/opentui\_rust](https://github.com/Dicklesworthstone/opentui_rust)
+> 2. DOM-like capture/bubble event dispatch · Issue \#650 · anomalyco,
+  [https://github.com/anomalyco/opentui/issues/650](https://github.com/anomalyco/opentui/issues/650)
+> 3. Proposal:  
+> 4. Proposal: The Grid™ · Issue \#553 · anomalyco/opentui \- GitHub,
+  [https://github.com/anomalyco/opentui/issues/553](https://github.com/anomalyco/opentui/issues/553)
+> 5. ASCIIFont \- OpenTUI,
+  [https://anomalyco-opentui.mintlify.app/components/asciifont](https://anomalyco-opentui.mintlify.app/components/asciifont)
+> 6. TUI command palette selection becomes unreadable when copy-highlighting · Issue \#9441 · anomalyco/opencode \-
+  GitHub, [https://github.com/anomalyco/opencode/issues/9441](https://github.com/anomalyco/opencode/issues/9441)
+> 7. tui/DROPDOWN.md at staging · positive-intentions/tui \- GitHub,
+  [https://github.com/positive-intentions/tui/blob/staging/DROPDOWN.md](https://github.com/positive-intentions/tui/blob/staging/DROPDOWN.md)
+> 8. opentui-dev | Skills Marketplace \- LobeHub,
+  [https://lobehub.com/skills/gitarbor-gitarbor-tui-opentui-dev](https://lobehub.com/skills/gitarbor-gitarbor-tui-opentui-dev)
+> 9. \[FEATURE\]: Add support for Linux PRIMARY selection (middle-click paste) \#29963 \- GitHub,
+  [https://github.com/anomalyco/opencode/issues/29963](https://github.com/anomalyco/opencode/issues/29963)
+> 10. Crash: stale insert/remove on destroyed parent triggers Yoga wasm Out of bounds call\_indirect · Issue \#733
+  · anomalyco/opentui \- GitHub,
+  [https://github.com/anomalyco/opentui/issues/733](https://github.com/anomalyco/opentui/issues/733)
+> 11. opentui | Agent Skills Library \- Awesome MCP Servers,
+  [https://mcpservers.org/agent-skills/msmps/opentui](https://mcpservers.org/agent-skills/msmps/opentui)
+> 12. Code \- OpenTUI, [https://opentui.com/docs/components/code/](https://opentui.com/docs/components/code/)

package/docs/SAVANT-VERSIONING.md

@@ -0,0 +1,31 @@
+# Savant Versioning
+
+**Current release:** Savant-Code `0.0.18`.
+
+Savant-Code does **not** use SemVer. It uses **Savant Versioning** — a base-10 iteration counter with epistemic resets.
+
+## Rules
+
+- Versions start at `0.0.1`, not `1.0.0`.
+- The last digit counts iterations: `0.0.1` → `0.0.2` → ... → `0.0.10`.
+- After 10 iterations, bump the middle digit: `0.0.10` → `0.1.0`.
+- A **paradigm break** (fundamentally different architecture/thinking) resets the entire count to `0.0.1` — even if
+  the underlying ideas are mature.
+
+## Why
+
+Industry SemVer is calibrated for teams that ship slowly. At Savant's dev velocity, SemVer would move `1.0.0` →
+`5.0.0` in a week — signaling "massive changes" when it's just normal iteration speed. The number becomes noise.
+
+Savant Versioning makes the version string a **humility meter**: `0.0.3` means "three iterations into the current
+foundation, still proving the base" — not "beta."
+
+The reset discipline is the moat: most teams carry a version number forward through a rewrite (pretending
+continuity). Savant resets because a paradigm break is a *new beginning*, not a continuation.
+
+## Example
+
+ECHO Protocol reset to `0.0.1` ~30 times during its multi-year development. Public `v0.0.3` (Savant-Code rebrand)
+is the 3rd iteration of the current foundation — but ECHO's *internal* maturity is ~v100 from the prior resets.
+
+*This is a Spencer-authored convention, not an industry standard.*

package/docs/Savant Code Launch Strategy.md

@@ -0,0 +1,270 @@
+# **Strategic Market Analysis and Launch Playbook for Savant Code**
+
+The following comprehensive analysis details the optimal go-to-market strategy, competitive positioning, and monetization framework for Savant Code. Set against the highly saturated 2025–2026 artificial intelligence coding agent landscape, this report provides empirical evidence and actionable directives for launching an Apache-2.0 licensed, TypeScript-based CLI tool. The developer ecosystem has recently experienced a paradigm shift; the initial enthusiasm for rapid, unverified code generation has given way to widespread "AI fatigue," driven by the high technical debt and debugging costs associated with hallucination-prone tools.  
+Savant Code’s core differentiators—an ECHO Protocol governance system, a 9-agent roster executing a self-auditing perfection loop, and a privacy-first Bring Your Own Key (BYOK) or local Ollama architecture—perfectly position the product to capture this frustrated demographic. The strategic imperatives detailed below synthesize distribution mechanics, competitor trajectories, pricing models, and community growth tactics to maximize market penetration.
+
+> **Product sequencing boundary:** The immediate strategy is to release and grow Savant-Code as a local/BYOK product. After user adoption, our team may design, build, and operate its own backend for a future free product. This strategy does not assume Savant-Free hosting, a Savant-Free partnership, or any external hosted-service dependency.
+
+## **1\. Launch Channels & Distribution Strategies**
+
+### **Optimal Launch Channels for Open-Source Developer Tools**
+
+The definitive answer regarding the most effective launch channels for open-source developer tools in the 2025–2026 market is that developer-centric community platforms heavily out-convert traditional product discovery sites. Specifically, Hacker News (HN) and highly targeted technical subreddits yield the most sustained, high-intent traffic for CLI-based utilities. Analysis of recent product launches indicates that traditional channels like Product Hunt have skewed toward consumer Software-as-a-Service (SaaS) and non-technical business tools, resulting in low retention for deep-tech utilities1.  
+Consequently, the actionable recommendation for Savant Code is to treat Hacker News as the primary launch vehicle, utilizing the "Show HN" format. Because Savant Code operates natively in the terminal and supports local models via Ollama, it aligns perfectly with the privacy-conscious, anti-hype ethos of the HN and Reddit demographics. Product Hunt should be relegated to a secondary, delayed launch channel aimed at general awareness rather than core user acquisition.
+
+### **Product Hunt vs. Hacker News vs. Reddit**
+
+When comparing these platforms, the data clearly shows that Hacker News and specific subreddits drive the most sustained traction for CLI developer tools. Hacker News actively rewards functional, immediately usable technical demos while aggressively penalizing marketing hyperbole and waitlists3. Reddit communities, particularly r/LocalLLaMA, r/MachineLearning, and r/ChatGPTCoding, act as highly critical but deeply engaged incubators for open-source AI projects. For instance, early iterations of CLI agents routinely gain initial footing in r/ChatGPTCoding before graduating to broader platforms5.  
+The actionable recommendation for Savant Code is to execute a sequenced launch. Begin with a soft launch in r/LocalLLaMA and r/ChatGPTCoding to battle-test the local Ollama integration and the 9-agent loop. Once edge-case bugs are resolved by this technical cohort, execute the primary "Show HN" submission.
+
+| Platform | Audience Profile | Optimal Content Format | Expected Traction Profile |
+| :---- | :---- | :---- | :---- |
+| **Hacker News** | Senior engineers, founders, skeptics | "Show HN", highly technical, no waitlists | Massive, immediate traffic spike; high conversion if frictionless. |
+| **Reddit (r/LocalLLaMA)** | Privacy-first AI researchers, tinkerers | Technical deep-dives, benchmark comparisons | Moderate volume, extremely high feedback quality and bug reporting. |
+| **Product Hunt** | Marketers, early adopters, VC analysts | Polished UI videos, consumer-friendly copy | High vanity metrics (upvotes), low long-term retention for CLI tools. |
+
+### **Developer Newsletters for Open-Source Projects**
+
+The most effective developer newsletters for open-source projects actively curate tools that improve the software development lifecycle without demanding immediate payment. Console.dev is a premier channel; it reviews the most interesting developer tools and beta releases for an audience of over 30,000 subscribers, strictly requiring that the tool is built for developers and offers self-service signup6. The Hacker Newsletter, which curates top HN posts for over 60,000 subscribers, is another vital distribution mechanism, though inclusion is entirely dependent on organic HN performance8. The TLDR Newsletter boasts a massive reach (7.2 million developers and tech workers) but largely operates on a paid sponsorship model for guaranteed placement10.  
+The actionable recommendation for Savant Code is to directly pitch the tool to Console.dev via their submission process, highlighting the open-source nature, the unique ECHO Protocol governance, and the local Ollama execution. Simultaneously, optimizing the Hacker News launch will organically secure placement in the Hacker Newsletter, achieving massive reach without advertising spend.
+
+### **Distribution Tactics of Successful Coding Agents**
+
+Successful coding agents have historically distributed their tools by removing all friction to the "first successful execution." Cline (formerly Claude Dev) distributed via the Visual Studio Code Marketplace, turning a complex autonomous agent into a one-click installation11. OpenHands (formerly OpenDevin) leveraged GitHub and Docker, allowing users to spin up a secure, isolated sandbox environment with a single terminal command12. Codebuff achieved its initial traction by offering a global npm installation (npm i \-g codebuff) combined with $20 in free credits, eliminating the need for users to configure API keys before experiencing the product's value13.  
+The actionable recommendation for Savant Code is to mirror the frictionless distribution of Codebuff and OpenHands. The installation must be achievable via a single command (e.g., npm i \-g savant-code). To eliminate API friction, the onboarding flow should automatically detect local Ollama instances and default to them, allowing the user to experience the 9-agent perfection loop immediately without entering credit card or API details.
+
+### **The Role of Social Media (Twitter/X vs. Decentralized Platforms)**
+
+While Twitter/X remains a viable platform for sharing highly visual coding demonstrations, the developer tool ecosystem has significantly fragmented. The open-source, privacy-advocate, and self-hosting communities have increasingly migrated to decentralized platforms like Mastodon and Bluesky. Furthermore, platforms like dev.to remain highly effective for long-form, tutorial-based content rather than direct launch announcements1.  
+The actionable recommendation for Savant Code is to utilize Twitter/X strictly for sharing high-speed, unedited terminal GIFs demonstrating the perfection loop catching an error before outputting code. Conversely, publish deep architectural breakdowns of the ECHO Protocol and the 9-agent roster on dev.to and Mastodon, catering to the engineers who value methodology over viral marketing.
+
+### **The Mechanics of GitHub Stars in Discovery**
+
+GitHub stars serve as the primary currency of social proof and discovery in the developer ecosystem. Projects that achieve rapid star growth frequently trigger inclusion in GitHub's "Trending" repositories, which acts as a massive organic growth loop. The velocity of stars within a 24-to-48-hour window is critical to this algorithm. OpenHands amassed over 82,000 stars by presenting a clear, transparent, open-source alternative to a highly hyped proprietary tool, backed by comprehensive README documentation15.  
+The actionable recommendation for Savant Code is to embed social proof mechanisms directly into the CLI workflow. After the agent successfully completes a complex, multi-file refactor through the perfection loop, the CLI should politely prompt the user: *"Savant Code saved you an estimated 45 minutes of debugging. If you found this useful, please star the repository at \[URL\]."* This converts satisfied usage directly into algorithmic momentum.
+
+## **2\. Competitor Launch Strategies and Market Positioning**
+
+### **Codebuff's Launch and Initial Traction**
+
+Codebuff launched as a Y Combinator-backed startup via a highly successful "Show HN" post, positioning itself as a CLI tool that modifies files based on natural language requests. The founders built traction by parsing the entire user codebase using the tree-sitter library and executing multi-file edits automatically13. However, the launch faced significant pushback regarding data privacy; users discovered that by-default usage transmitted source code, prompts, and command history to Codebuff's servers, and the terms of service allowed the company to reproduce and distribute user content13.  
+The actionable recommendation for Savant Code is to aggressively capitalize on the privacy backlash faced by tools like Codebuff. Savant Code’s messaging must explicitly highlight its BYOK architecture and local Ollama compatibility, guaranteeing that proprietary codebase data never leaves the user's machine. Privacy must be positioned as a core architectural feature, not an afterthought.
+
+### **The Trajectory of Cline (Claude Dev)**
+
+Cline originally launched as "Claude Dev," an entry in Anthropic's June 2024 hackathon. It grew rapidly from zero to a massive user base by functioning as an autonomous software engineer within the IDE, capable of reading files, creating projects, and executing terminal commands18. Despite a rebranding to Cline, the tool retained its original VS Code extension ID (saoudrizwan.claude-dev) to preserve its installed user base and marketplace ranking11. However, Cline has faced severe security scrutiny; reports indicate that it stores API keys and Model Context Protocol (MCP) credentials in plaintext JSON files, which can be inadvertently synced to public repositories via VS Code Settings Sync19.  
+The actionable recommendation for Savant Code is to differentiate heavily on security. Where Cline leaves credentials vulnerable, Savant Code must implement enterprise-grade secret management for its BYOK implementation. The ECHO Protocol should be marketed as a safeguard that not only audits code quality but strictly governs what the agent is permitted to execute, preventing rogue commands.
+
+### **OpenHands (OpenDevin) and the 50K+ Star Explosion**
+
+OpenHands gained unprecedented traction by capitalizing on the viral marketing of "Devin," a proprietary autonomous agent. By launching "OpenDevin" as an open-source alternative aimed at replicating and enhancing Devin's capabilities, the project galvanized a community desperate for an open, transparent alternative20. The project achieved over 82,000 stars by utilizing a Docker-based sandbox environment that securely isolated the agent's file system and browser interactions, ensuring that autonomous actions did not compromise the host machine12.  
+The actionable recommendation for Savant Code is to adopt OpenHands' narrative of transparency and community ownership. Savant Code should emphasize that proprietary agents are "black boxes" that generate technical debt, whereas Savant Code’s 9-agent perfection loop operates entirely in the open, allowing developers to inspect the reasoning process step-by-step.
+
+### **Block's Strategy with Goose**
+
+Goose was released by Block's Open Source Team as an extensible, on-machine AI agent capable of executing code and workflows via various LLMs. Block leveraged its corporate weight, utilizing the Square Developer Podcast and internal engineering networks to promote the tool21. Goose differentiated itself by offering over 70 extensions, allowing the agent to interact with a wide array of developer tools and environments23.  
+The actionable recommendation for Savant Code is to acknowledge that it cannot compete with Block's corporate distribution muscle. Instead, Savant Code must compete on depth rather than breadth. While Goose offers dozens of general extensions, Savant Code must focus relentlessly on the single, highest-value pain point: code accuracy. The 9-agent perfection loop must be marketed as an architecturally superior method for ensuring bug-free code, outperforming generalist agents.
+
+### **Pricing Models in the Coding Agent Ecosystem**
+
+The market is currently fragmented across several monetization strategies. Tools like Codebuff utilize a Freemium model with high-cost paid tiers (e.g., $99/month) to offset the massive inference costs of passing entire codebases as context13. Other platforms utilize seat-based models for enterprise teams. Conversely, open-source agents like OpenHands and Cline rely entirely on a BYOK model, where the user supplies the API key, shifting the inference cost away from the maintainers11.
+
+| Competitor | Core Architecture | Monetization / Pricing Model | Key Vulnerability / Criticism |
+| :---- | :---- | :---- | :---- |
+| **Codebuff** | Terminal CLI, Tree-sitter | Freemium ($99/mo premium tier) | Severe data privacy concerns; code sent to centralized servers. |
+| **Cline** | VS Code Extension | BYOK (User pays API costs) | Security risks; plaintext storage of API keys and MCP credentials. |
+| **OpenHands** | Docker Sandbox, Web UI | BYOK / Open Source | High barrier to entry; requires Docker orchestration. |
+| **Goose (Block)** | On-machine, Extensible | Open Source (Corporate backed) | Generalist approach; lacks specialized self-correction loops. |
+
+The actionable recommendation for Savant Code is to strictly adhere to a BYOK and local-first (Ollama) model for the open-source tier. Attempting to provide hosted inference for a 9-agent multi-step loop on a free tier will result in immediate financial ruin due to exorbitant token consumption.
+
+### **Conversion Rates from Free to Paid**
+
+In the developer tools sector, typical conversion rates from a free tier to a paid tier hover between 2% and 5%. These conversions are almost exclusively driven by enterprise requirements rather than individual developer needs. Developers will utilize a free tool indefinitely; engineering managers upgrade to paid tiers to acquire Single Sign-On (SSO), Role-Based Access Control (RBAC), audit logging, and team-based context sharing25.  
+The actionable recommendation for Savant Code is to design the future monetization strategy entirely around the ECHO Protocol. While the CLI and the perfection loop remain free and local, the paid tier should offer a centralized dashboard where engineering leaders can enforce specific ECHO Protocol rules (e.g., mandatory security audits, unified style guides) across an entire organization's deployed Savant Code agents.
+
+## **3\. Pricing, Monetization, and Inference Economics**
+
+### **Ad CPM Realities for CLI Text Ads**
+
+The expectation of a $20–$45 CPM for CLI text ads is unrealistic in the current market. Standard developer-focused ad networks, such as EthicalAds, yield a CPM between $1 and $5, focusing on privacy-centric, non-tracking placements26. Carbon Ads, which targets high-quality developer tools and documentation, typically yields a CPM of $3 to $1026. While highly contextual, native in-IDE ad placements (such as those experimented with by emerging tools like Idlen) have reported click-through rates 10 times higher than traditional display ads, baseline impressions rarely command $45 CPMs27.  
+The actionable recommendation for Savant Code is to build financial models based on a conservative $4 to $6 CPM. Revenue should be viewed as supplementary income to offset open-source maintenance costs rather than a venture-scale revenue stream.
+
+### **Ad-Supported Models and CLI Ad Networks**
+
+Implementing advertisements in a terminal environment requires extreme care to avoid alienating the developer base. Carbon Ads has pioneered a specific CLI SDK designed for terminal applications. This SDK provides a headless API (fetchAd()) that returns text, images, and background colors without executing malicious tracking code28. Crucially, the Carbon Ads CLI implementation features a fail-safe design with a hard 5-second timeout, ensuring that if the ad network fails to respond, the developer tool continues to function seamlessly without breaking28.  
+The actionable recommendation for Savant Code is to integrate the Carbon Ads CLI SDK. The ad should be displayed during the natural latency window of the perfection loop. Because a 9-agent audit takes time, displaying a highly relevant, privacy-respecting text ad (e.g., for a cloud hosting provider) while the user waits for the audited code acts as a natural loading screen, minimizing user frustration.
+
+### **Structuring Free Tier vs. Paid Tier**
+
+Successful developer tools enforce a clear demarcation between individual utility and team-based collaboration. The free tier typically includes the core functional engine, local execution, and community support. The paid tier introduces governance, compliance, and centralized administration25.  
+The actionable recommendation for the initial Savant-Code release is to keep the local/BYOK product uncrippled regarding code generation. The full 9-agent roster and the perfection loop should be available to users utilizing their own compute (Ollama) or API keys. After Savant-Code gains users, the team can evaluate and build its own independently operated backend/free product; that future service is not part of the initial release or a current hosting commitment. Any paid enterprise tier should be designed later around ECHO Protocol governance, compliance, and administration.
+
+### **Break-Even Point for Free-Tier Inference**
+
+Providing free hosted inference for a multi-agent system is economically unviable as an initial launch assumption. Modern AI inference, particularly for autonomous loops that rely heavily on maintaining large contexts in memory (KV Cache), requires massive memory bandwidth30. As an agent critiques and rewrites code through 9 distinct personas, the token generation and context window consumption compound exponentially. A single complex refactoring task could consume tens of thousands of tokens.
+The actionable recommendation is to launch Savant-Code with local Ollama and BYOK, so users bear their own compute costs. After the product gains users, the team may model the economics and build an independently operated backend for a future free product if the evidence supports it. That future backend is not available at initial launch and does not depend on Savant-Free or any external hosting partner.
+
+### **The "Data for Compute" Model**
+
+An emerging economic model in the AI sector involves trading compute access for high-quality developer data. High-fidelity data detailing how senior developers resolve complex architectural problems, navigate codebases, and iterate on errors is immensely valuable for training the next generation of reasoning models (e.g., OpenAI's "o" series or Anthropic's advanced iterations). Research firms and frontier model developers actively seek "Workplace Activity Graphs" and operational telemetry to evaluate and train agents32.  
+A possible later-stage research direction is an opt-in "Data for Compute" program, but it is not part of the Savant-Code launch plan. Only after Savant-Code gains users and the team has designed and built its own backend should this or any future free-inference model be evaluated. Any such service would require separate privacy, security, economics, legal, and governance decisions; no Savant-Free hosting, partnership, or external service dependency is assumed.
+
+## **4\. Pre-Launch Preparation**
+
+### **Requirements for a Launch-Ready Open-Source Project**
+
+The Hacker News community aggressively penalizes projects that launch before they are usable. A launch-ready open-source project must contain a functional repository that allows a user to go from discovery to execution in under two minutes. Essential components include an Apache-2.0 LICENSE, a CONTRIBUTING.md file establishing governance rules, and a README.md that prioritizes installation commands over marketing fluff2.  
+The actionable recommendation for Savant Code is to ensure the repository is immaculate. The README must begin with a clear, one-sentence description of the tool, immediately followed by an animated GIF showing the perfection loop in the terminal. The installation section must provide the npm i \-g savant-code command and explicit instructions for linking a local Ollama instance.
+
+### **Landing Page vs. GitHub Repository**
+
+While the GitHub repository is the ultimate destination, a landing page is a critical asset for controlling the narrative and establishing brand legitimacy. Hacker News guidelines stipulate that "Show HN" submissions must link to something users can try, meaning a link directly to a GitHub repo with clear instructions is often preferred by purists3. However, a minimalist landing page distills complex multi-agent architectures into digestible visual concepts for the broader market.  
+The actionable recommendation for Savant Code is to build a high-performance, dark-mode landing page that serves as a visual primer for the GitHub repository. The hero section should feature a split-screen video: on the left, a standard agent failing to resolve a dependency error; on the right, Savant Code’s 9-agent loop identifying the error, critiquing the approach, and rewriting the code perfectly. The primary Call to Action (CTA) must link directly to the GitHub repository.
+
+### **Optimal Documentation Structure**
+
+Developer tool documentation must balance immediate usability with deep architectural transparency. A massive, sprawling README intimidates users, while sparse documentation prevents power users from customizing the tool.  
+The actionable recommendation for Savant Code is to adopt a hybrid structure. The GitHub README should be strictly action-oriented: Installation, Basic Usage, and Configuration of BYOK/Ollama. All deep technical details—such as the specific prompts used by each of the 9 agents, the methodology of the ECHO Protocol, and the architecture of the perfection loop—should be hosted on a dedicated documentation site (e.g., docs.savantcode.dev) built with Docusaurus or Mintlify.
+
+### **Discord/Slack Community Timing**
+
+Building the community infrastructure prior to launch is non-negotiable. When the launch traffic spikes, users will inevitably encounter environmental bugs, operating system discrepancies, or API rate limits. Without a centralized communication channel, these users will abandon the tool or flood the GitHub repository with low-quality issues. Open-source projects like OpenHands utilized Slack and Discord from day one to triage feedback and foster a contributor base12.  
+The actionable recommendation for Savant Code is to launch a Discord server prior to the public announcement. Create strictly categorized channels: \#announcements, \#ollama-setup, \#byok-support, and \#echo-protocol-feedback. Embed the Discord invite link in the GitHub README, the landing page, and as a concluding message in the terminal upon successful installation.
+
+### **Timing Between First Commit and Official Launch**
+
+The ideal time between the first public commit and the official launch is short—typically a matter of weeks. The open-source community respects momentum and iteration. Waiting to achieve a "perfect" v1.0 often results in building features in a vacuum without user validation. Codebuff's founders noted that the core concept was built during a weekend hackathon, and rapid iteration based on user feedback drove their eventual success13.  
+The actionable recommendation for Savant Code is to avoid "perfection paralysis." If the core 9-agent perfection loop operates reliably and the BYOK/Ollama integrations function without crashing, the project is ready for launch. The ad infrastructure can remain inactive during the initial week to ensure the core value proposition is proven before introducing monetization elements.
+
+## **5\. Launch Timing & Sequencing**
+
+### **Optimal Day and Time for a Developer Launch**
+
+The algorithmic mechanics of Hacker News are governed by a formula that heavily discounts the value of votes over time (age decay). Consequently, achieving early velocity—a rapid accumulation of upvotes in the first 60 to 90 minutes—is the sole determinant of reaching the front page4. Empirical data indicates that the optimal window for maximum engagement from the US-based engineering cohort is Tuesday, Wednesday, or Thursday between 8:00 AM and 10:00 AM Eastern Time (ET)2.  
+The actionable recommendation for Savant Code is to schedule the launch for a Tuesday at 8:30 AM ET. This captures the east coast engineering audience as they begin their workday and the European audience in their early afternoon, maximizing the potential for early upvote velocity.
+
+### **The Strategic Necessity of a Soft Launch**
+
+A soft launch is a critical risk mitigation strategy. Releasing a complex CLI tool that interacts with local environments directly to 50,000 users guarantees that edge-case bugs (e.g., Windows file pathing issues, Node.js version conflicts) will derail the launch narrative.  
+The actionable recommendation for Savant Code is to execute a quiet soft launch one week prior to the HN submission. Post the tool in r/LocalLLaMA and r/ChatGPTCoding, explicitly framing it as a beta test: *"I built a 9-agent coding loop that self-audits. Need help stress-testing the local Ollama integration before I launch."* This cohort will uncover environmental bugs, allowing the team to push patches before the high-stakes Hacker News launch.
+
+### **Sequencing the Launch Across Channels**
+
+To maintain sustained algorithmic momentum, the launch must be sequenced across channels rather than blasted simultaneously.
+
+| Phase | Channel | Timeline | Objective |
+| :---- | :---- | :---- | :---- |
+| **Phase 1: Soft Launch** | r/LocalLLaMA, r/ChatGPTCoding | T-Minus 7 Days | Identify fatal bugs, test Ollama integration, gather initial testimonials. |
+| **Phase 2: Primary Launch** | Hacker News ("Show HN") | Day 0 (8:30 AM ET) | Trigger massive traffic spike, acquire core user base, drive GitHub stars. |
+| **Phase 3: Amplification** | Twitter/X, Mastodon | Day 0 (12:00 PM ET) | Leverage HN success ("We hit \#1 on HN\!") to drive social sharing and visual GIF engagement. |
+| **Phase 4: Long Tail** | Console.dev, TLDR submissions | Day \+3 | Submit to newsletters using the established social proof to guarantee inclusion. |
+| **Phase 5: Mainstream** | Product Hunt | Day \+14 | Target the broader tech ecosystem and VC analysts after the core tool is highly stable. |
+
+### **The "Launch Week" Playbook**
+
+The actions taken in the first two hours of the Hacker News launch dictate its success. HN strictly prohibits asking for upvotes, and their ring-detection algorithms will shadowban the domain if coordinated voting is detected2.  
+The actionable recommendation for Savant Code is to prepare a detailed, humble, and highly technical first comment to append immediately after submitting the link. This comment must detail *why* the tool was built, the specific architecture of the 9-agent roster, the trade-offs made (e.g., "It's slower than Copilot, but the code actually works"), and what is currently broken1. For the subsequent two hours, the founders must remain at their keyboards, replying factually and non-defensively to every critique and question.
+
+### **Maintaining 30/60/90 Day Momentum**
+
+Post-launch drop-off is inevitable unless a strict update cadence is maintained. The actionable recommendation for Savant Code is:
+
+* **30 Days:** Focus entirely on stability, community feedback, and compatibility after the Savant-Code release. Do not activate hosted inference or advertising infrastructure by default.
+* **60+ Days:** Measure adoption and user needs, then decide whether to begin designing our own backend for a future free product. This is an investigation milestone, not a promised hosted launch.
+* **90+ Days:** If adoption and capacity justify it, prototype the first-party backend under a separate FID with independent privacy, security, economics, and operational gates; otherwise continue improving the local/BYOK Savant-Code product.
+
+## **6\. Community & Growth Dynamics**
+
+### **Building an Early Adopter Community**
+
+The most effective method for cultivating a dedicated community around a coding agent is radical architectural transparency. Developers are inherently skeptical of "black box" AI tools that abstract away prompt engineering and contextual retrieval mechanisms. OpenHands succeeded because it allowed the community to dissect, debate, and modify the underlying agentic logic16.  
+The actionable recommendation for Savant Code is to open-source the specific prompts and evaluation criteria utilized by the 9-agent roster. Host weekly "Architecture Sync" voice channels in the Discord server, inviting developers to debate the efficacy of the perfection loop and propose structural improvements to the ECHO Protocol.
+
+### **Sourcing Beta Testers and Targeting Early Adopters**
+
+Developer early adopters congregate in environments where they are actively trying to solve the limitations of current tools. GitHub issue trackers for incumbent agents (e.g., Cline, Aider, Cursor) are goldmines of frustrated users documenting infinite loops, context window failures, and lazy code generation.  
+The actionable recommendation for Savant Code is to monitor these issue trackers and adjacent subreddits. When a developer posts a detailed complaint about an agent hallucinating a non-existent API endpoint, reach out directly: *"I saw your issue with \[Competitor\]. I built Savant Code with a 9-agent perfection loop specifically to catch those hallucinations before the code is output. Would love your feedback on the architecture."*
+
+### **The Role of Influencers in Dev Tool Launches**
+
+Technical content creators on YouTube hold immense sway over top-of-funnel awareness. Videos titled "Cursor vs. Cline vs. OpenHands" routinely generate hundreds of thousands of views, driving massive installation spikes33. These creators are constantly searching for novel capabilities to showcase to their audiences.  
+The actionable recommendation for Savant Code is to avoid traditional paid sponsorships. Instead, provide top technical YouTubers with a pre-configured, highly visual demonstration of the perfection loop catching a subtle, complex bug that Claude 3.5 or GPT-4o typically fail to resolve on the first pass. The visual nature of the self-correction process is highly compelling video content.
+
+### **Handling Feature Requests Without Losing Direction**
+
+Open-source projects frequently suffer from mission drift when maintainers accept pull requests that dilute the core value proposition in an attempt to please every user.  
+The actionable recommendation for Savant Code is to utilize the ECHO Protocol as the definitive constitutional document for the project. If a user submits a PR to bypass the perfection loop in order to increase generation speed, it must be rejected with a clear reference to the project's core philosophy: *"Savant Code prioritizes absolute code accuracy over generation speed."* Establishing strict ideological boundaries attracts developers who share that exact philosophy.
+
+## **7\. Risk Mitigation & Competitive Differentiation**
+
+### **Major Risks in the 2025–2026 Market**
+
+The AI coding agent market is fraught with two primary risks: catastrophic security vulnerabilities and acute market fatigue. Coding agents possess the permissions of the host user; if compromised via prompt injection or insecure credential storage, they can delete production databases, leak SSH keys, or execute malicious payloads19. Furthermore, developers are experiencing severe "AI fatigue," spending more time reviewing, debugging, and babysitting AI-generated code than they would have spent writing it manually36.  
+The actionable recommendation for Savant Code is to make security a cornerstone of the launch messaging. Publicly document the cryptographic handling of BYOK credentials and the sandbox protocols preventing unauthorized terminal execution. Savant Code must be positioned as the secure, reliable antithesis to reckless, speed-optimized agents.
+
+### **Differentiating from Established Players**
+
+Established players like GitHub Copilot, Cursor, and Cline optimize heavily for low-latency generation. This design choice inherently sacrifices deep reasoning and iterative auditing, resulting in code that is fast but frequently flawed.  
+The actionable recommendation for Savant Code is to position the tool as the "Senior Engineer" to the competitors' "Junior Developer." The marketing narrative should explicitly contrast the paradigms: *"Other tools generate code instantly, leaving you to debug it. Savant Code takes 30 seconds longer, because it audits, critiques, and rewrites its own work through a 9-agent loop before it ever hits your screen."*
+
+### **Messaging for Frustrated Developers**
+
+The most resonant messaging acknowledges the painful reality of current AI coding workflows. Developers do not want faster code generation; they want code they do not have to fix.  
+The actionable recommendation for Savant Code is to adopt aggressive, empathetic copywriting. Use taglines such as: *"Stop babysitting your AI,"* or *"The first coding agent that actually reviews its own pull requests."* Highlight the perfection loop as the ultimate cure for AI hallucinations.
+
+### **Positioning "Quality Over Speed"**
+
+In a market obsessed with token generation speed, claiming "slowness" as a feature is a highly differentiated, contrarian strategy. However, the slowness must be verifiable and transparent.  
+The actionable recommendation for Savant Code is to design the CLI interface to visualize the perfection loop in real-time. Do not hide the delay behind a loading spinner. Instead, stream the internal monologue of the agents to the terminal (e.g., *"Agent 3 (Security Auditor): Identified a potential SQL injection vulnerability on line 42\. Routing back to Agent 1 for rewrite."*). By making the rigorous auditing process visible, the delay becomes a highly valued feature rather than a detriment.
+
+### **Common Mistakes That Kill Dev Tool Launches**
+
+The most fatal mistakes in launching an open-source dev tool involve violating the trust and cultural norms of the engineering community. These include:
+
+> 1. Using LLMs to write the Hacker News launch copy or responding to comments with corporate marketing-speak3.  
+> 2. Launching behind a waitlist, email capture form, or mandatory sales call2.  
+> 3. Soliciting fake upvotes from friends, which triggers Hacker News ring-detection algorithms and results in domain shadowbans4.  
+> 4. Releasing a broken core feature (e.g., an npm package that fails to install on standard operating systems).
+
+The actionable recommendation for Savant Code is to maintain absolute authenticity. Write all launch materials by hand. Ensure the tool is immediately accessible with zero signup friction. A highly functional, radically honest launch of a slightly unpolished tool will always outperform a heavily marketed, gated launch in the developer ecosystem.
+
+#### **Works cited**
+
+> 1. Hacker News Posting Guide: Rules, Show HN, and Timing \- Syften, [https://syften.com/blog/hacker-news-marketing/](https://syften.com/blog/hacker-news-marketing/)  
+> 2. How to Launch on Hacker News and Get Traction (2026) | Okara Blog, [https://okara.ai/blog/how-to-launch-on-hacker-news](https://okara.ai/blog/how-to-launch-on-hacker-news)  
+> 3. How to Submit a Show HN \- GitHub, [https://gist.github.com/tzmartin/88abb7ef63e41e27c2ec9a5ce5d9b5f9](https://gist.github.com/tzmartin/88abb7ef63e41e27c2ec9a5ce5d9b5f9)  
+> 4. Hacker News Front Page 2026: The Playbook (Timing, Titles \+ the Ranking Formula), [https://www.flowjam.com/blog/how-to-get-on-the-front-page-of-hacker-news-in-2025-the-complete-up-to-date-playbook](https://www.flowjam.com/blog/how-to-get-on-the-front-page-of-hacker-news-in-2025-the-complete-up-to-date-playbook)  
+> 5. Claude Dev vscode extension : r/ChatGPTCoding \- Reddit, [https://www.reddit.com/r/ChatGPTCoding/comments/1f6242l/claude\_dev\_vscode\_extension/](https://www.reddit.com/r/ChatGPTCoding/comments/1f6242l/claude_dev_vscode_extension/)  
+> 6. console.dev Selection Criteria, [https://console.dev/selection-criteria](https://console.dev/selection-criteria)  
+> 7. console.dev \- a free weekly devtools newsletter, [https://console.dev/](https://console.dev/)  
+> 8. Hacker Newsletter, [https://hackernewsletter.com/](https://hackernewsletter.com/)  
+> 9. Become a Better Entrepreneur by Subscribing to These 5 Newsletters, [https://www.entrepreneur.com/leadership/become-a-better-entrepreneur-by-subscribing-to-these-5/244041](https://www.entrepreneur.com/leadership/become-a-better-entrepreneur-by-subscribing-to-these-5/244041)  
+> 10. Advertise in TLDR | Newsletter Advertising for Tech Brands, [https://advertise.tldr.tech/](https://advertise.tldr.tech/)  
+> 11. Cline for VS Code: Free AI Coding Agent Setup Guide (2026) \- DeployHQ, [https://www.deployhq.com/guides/cline](https://www.deployhq.com/guides/cline)  
+> 12. invariantlabs-ai/OpenDevin: OpenDevin: Code Less, Make More \- GitHub, [https://github.com/invariantlabs-ai/OpenDevin](https://github.com/invariantlabs-ai/OpenDevin)  
+> 13. Launch HN: Codebuff (YC F24) – CLI tool that writes code for you | Hacker News, [https://news.ycombinator.com/item?id=42078536](https://news.ycombinator.com/item?id=42078536)  
+> 14. 10 useful web development newsletters \- DEV Community, [https://dev.to/dailydotdev/10-useful-web-development-newsletters-37nf](https://dev.to/dailydotdev/10-useful-web-development-newsletters-37nf)  
+> 15. OpenHands: AI-Driven Development \- GitHub, [https://github.com/OpenHands/openhands](https://github.com/OpenHands/openhands)  
+> 16. Star History Monthly Sep 2025 | Proprietary AI Alternatives, [https://www.star-history.com/blog/proprietary-ai-alternatives/](https://www.star-history.com/blog/proprietary-ai-alternatives/)  
+> 17. MAL-2026-4533 malware advisory: critical-severity | Corgea, [https://corgea.com/advisories/malware/MAL-2026-4533](https://corgea.com/advisories/malware/MAL-2026-4533)  
+> 18. My submission to Anthropic's Build with Claude June 2024 hackathon: Claude Dev, an autonomous software engineer right in your IDE. Open source and available on VSCode marketplace now\! \- Reddit, [https://www.reddit.com/r/ChatGPTCoding/comments/1e4k70g/my\_submission\_to\_anthropics\_build\_with\_claude/](https://www.reddit.com/r/ChatGPTCoding/comments/1e4k70g/my_submission_to_anthropics_build_with_claude/)  
+> 19. AI coding assistants are leaking credentials: a research breakdown | Netwrix, [https://netwrix.com/en/resources/blog/ai-coding-assistant-credential-storage-risks/](https://netwrix.com/en/resources/blog/ai-coding-assistant-credential-storage-risks/)  
+> 20. OpenDevin: Code Less, Make More \- OpenCSG (开放传神), [https://opencsg.com/codes/AIWizards/OpenDevin](https://opencsg.com/codes/AIWizards/OpenDevin)  
+> 21. You Don't Need to Build Your AI Agent — Just Use Goose \- Agentailor, [https://blog.agentailor.com/posts/goose-open-source-agent-quickstart](https://blog.agentailor.com/posts/goose-open-source-agent-quickstart)  
+> 22. Codename Goose – Your Next Open Source AI Agent \- Square, [https://squareup.com/us/en/the-bottom-line/podcasts/the-square-developer-podcast/goose](https://squareup.com/us/en/the-bottom-line/podcasts/the-square-developer-podcast/goose)  
+> 23. GitHub \- aaif-goose/goose: an open source, extensible AI agent that goes beyond code suggestions \- install, execute, edit, and test with any LLM, [https://github.com/aaif-goose/goose](https://github.com/aaif-goose/goose)  
+> 24. AWS Marketplace: OpenHands \- Hardened Self-Hosted AI Software Engineering Agent, [https://aws.amazon.com/marketplace/pp/prodview-uvruzgvnctso2](https://aws.amazon.com/marketplace/pp/prodview-uvruzgvnctso2)  
+> 25. Codebuff vs. Maguyva Comparison \- SourceForge, [https://sourceforge.net/software/compare/Codebuff-vs-Maguyva/](https://sourceforge.net/software/compare/Codebuff-vs-Maguyva/)  
+> 26. 100 Ways to Earn Extra Cash as a Developer \- DEV Community, [https://dev.to/alishirani/100-ways-to-earn-extra-cash-as-a-developer-6dk](https://dev.to/alishirani/100-ways-to-earn-extra-cash-as-a-developer-6dk)  
+> 27. How to Reach Software Developers: The Definitive Channel Guide | daily.dev Ads, [https://business.daily.dev/resources/software-developers-reach-channel-guide/](https://business.daily.dev/resources/software-developers-reach-channel-guide/)  
+> 28. Monetize Your CLI Tool — Early Access | Carbon Ads, [https://www.carbonads.net/cli](https://www.carbonads.net/cli)  
+> 29. Architecting Your Predictive Analytics Pipeline on OpenMetal for Speed and Accuracy, [https://openmetal.io/resources/blog/architecting-your-predictive-analytics-pipeline-on-openmetal-for-speed-and-accuracy/](https://openmetal.io/resources/blog/architecting-your-predictive-analytics-pipeline-on-openmetal-for-speed-and-accuracy/)  
+> 30. What Are Graphics Processing Units (GPUs) and Why They Matter for AI \- MinIO, [https://www.min.io/learn/graphics-processing-units](https://www.min.io/learn/graphics-processing-units)  
+> 31. Domain specific architectures for AI inference \- fleetwood.dev, [https://fleetwood.dev/posts/domain-specific-architectures](https://fleetwood.dev/posts/domain-specific-architectures)  
+> 32. Research Index \- Gerra, [https://www.gerra.com/research](https://www.gerra.com/research)  
+> 33. Weekly AI Roundup: CodeBuff Beats Claude Code, ByteDance Seedream 4.0, Alibaba 80B Model & More \- YouTube, [https://www.youtube.com/watch?v=GFJBGs\_OnOA](https://www.youtube.com/watch?v=GFJBGs_OnOA)  
+> 34. project-copilot/claude-dev: Autonomous coding agent right in your IDE, capable of creating/editing files, executing commands, and more with your permission every step of the way. · GitHub, [https://github.com/project-copilot/claude-dev](https://github.com/project-copilot/claude-dev)  
+> 35. AI Coding Tools \- Yale Center for Research Computing, [https://docs.ycrc.yale.edu/ai/aicodingtools/](https://docs.ycrc.yale.edu/ai/aicodingtools/)  
+> 36. AI doesn't reduce work, it intensifies it \- Hacker News, [https://news.ycombinator.com/item?id=46955703](https://news.ycombinator.com/item?id=46955703)  
+> 37. Edit (2026-03-28): we can't respond to emails about this any more because there ... | Hacker News, [https://news.ycombinator.com/item?id=22336638](https://news.ycombinator.com/item?id=22336638)