Ashwatth Blog
Deep dives, architecture pivots, and technical lessons from building an autonomous full-stack co-engineer.
The Spark: Why Raw Code Generation Alone Is Not Enough
Software development has become fragmented across disconnected chatbots, Jira tickets, and ephemeral docs. Why AI needs to understand the overarching architecture rather than just isolated prompts.
Sketching First: Why Developer Experience Precedes Model Intelligence
Long before orchestrating complex agent loops, we spent weeks sketching developer workflows. How the user interface shapes human-AI cooperation.
First Principles: From Traditional Software to Transformers & Graph ASTs
We came from traditional engineering backgrounds. To build an AI co-engineer, we went back to first principles: linear algebra, self-attention, token probabilities, and graph structures for codebases.
The Multi-Agent Graph Prototype: What Worked and What Broke
Building our initial system using LangChain and LangGraph with specialized task nodes. Why nested sub-graphs introduced high latency and debugging nightmares.
Beyond the Graph: Tool-Calling Loops, Persistent Memory & MCP
Moving from fragile static graphs to dynamic tool calling, shell execution, Model Context Protocol (MCP), and persistent memory pools that prevent repetitive agent mistakes.
Starting Over: Why We Deleted Our Entire Codebase to Rebuild Lean
Accepting that refactoring a legacy graph system was a dead end. Wiping the repository clean to rebuild a deterministic agent engine from scratch.
Chopping Complexity: Pruning from 5 Overwhelming Tabs to 3 Core Views
Developer cognitive load is the ultimate bottleneck. How we ruthlessly pruned dashboard bloat into three streamlined views: Docs, Kanban, and Build.
Beyond Tabs: Why Tabbed Navigation Still Breaks Developer Flow
Pruning 5 tabs to 3 tabs (Docs, Kanban, Build) was a great leap, but tabbed interfaces still forced continuous context-switching. Why software architecture cannot be trapped in page silos.
The Canvas Breakthrough: Unifying Architecture and Code on a 2D Plane
Collapsing Docs, Kanban, and Build onto an infinite 2D spatial plane. How unifying living PRDs, UI storyboards, database schemas, and a sliding IDE created a single source of truth.
Why Massive Prompt Dumps Break Codebases: The Case for Branch-Isolated Execution
When AI tries to rewrite 10 files in a single turn, hallucinations cascade and builds break. How decomposing feature specs into atomic Kanban tasks on isolated Git branches eliminates code rot.
Curing LLM Amnesia: Building a Persistent Architectural Memory Bank
After 20 turns, standard LLMs lose architectural context and re-introduce rejected bugs. How persistent engineering journals and read-only Discuss Mode protect codebases.
The Vision Today: Autonomous Co-Engineering and Collaborative Workspaces
The future of software engineering is human-AI partnership. Opening our private beta and inviting early builders to shape the autonomous co-engineering platform.