Agentic Spagetti Code Prevention

Learn how TangleGuard helps control agent-generated code architecture. This talk demonstrates setting up target architectures and using AI agents to produce aligned code, ensuring scalability and maintainability.

Claude Code Rust tree-sitter Layered architecture Hexagonal architecture

Overview

TangleGuard helps agentic engineers to control their codebase architecture. In the demo I’ll show how to set up a target architecture using common architectural styles (like a layered architecture, and hexagonal architecture) for a specific codebase. Then, I’ll show how AI agents can use that indented structural information to produce code that aligned with the intended structure (via CLI + Skill or MCP).

Links

https://tangleguard.com/
Archwise's TangleGuard compiles software artifacts into a language-agnostic Intermediate Representation to resolve circular dependencies.
https://app.tangleguard.com/
TangleGuard Cloud analyzes open-source dependency graphs and architectural cycles.

Tech stack

Claude Code

Anthropic's agentic coding tool: Unleash Claude's raw power directly in your terminal or IDE to turn complex, hours-long workflows into a single command.

Claude Code is Anthropic’s powerful agentic coding assistant, designed for high-velocity development. It operates natively within your terminal, IDE (VS Code, JetBrains), or via a web interface, allowing you to delegate complex tasks like feature building, bug fixing, and codebase navigation. The agent plans, edits files, executes commands, and creates commits, maintaining awareness of your entire project structure. Internally, Anthropic engineers using Claude Code reported a 67% increase in productivity, demonstrating its capacity to deliver significant gains for Pro and Max plan users.

https://claude.com/code

View projects
Rust

Rust is a high-performance systems programming language that guarantees memory and thread safety via its compile-time ownership model.

Rust is a statically-typed systems language engineered for performance and reliability, directly challenging C/C++ in speed. Its core innovation is the ownership model and 'borrow checker,' which enforces strict memory and thread safety at compile-time, eliminating data races and null pointer dereferences without a conventional garbage collector. Rust achieves near-native speed through 'zero-cost abstractions,' allowing high-level features to compile into highly optimized code. Major industry players, including Microsoft and Cloudflare, leverage Rust for critical infrastructure, and it is now officially supported for development in the Linux kernel.

https://www.rust-lang.org/

View projects
tree-sitter

An incremental parsing library that builds concrete syntax trees and updates them efficiently during live editing.

Tree-sitter generates robust syntax trees using a C-based runtime and language-specific grammars. It supports over 40 languages (including Rust, JavaScript, and Python) to power features like syntax highlighting and code navigation in Neovim and GitHub. The engine handles syntax errors gracefully and re-parses modified code in O(log n) time. This efficiency ensures immediate feedback without blocking the main editor thread.

https://tree-sitter.github.io/tree-sitter/

View projects
Layered architecture

Layered architecture partitions an application into distinct horizontal tiers to isolate core business rules from user interfaces and databases.

This pattern (often called n-tier architecture) organizes software components into stacked horizontal layers: typically presentation, business logic, persistence, and database. By enforcing a strict top-down flow where each layer only communicates with the one directly below it, developers achieve a clean separation of concerns. This isolation makes it straightforward to swap out a frontend framework or run isolated unit tests on business logic without touching the underlying database. It remains the industry standard for traditional enterprise applications and CRUD-heavy systems that require predictable, modular codebases.

https://www.geeksforgeeks.org/software-architectural-patterns-in-system-design/

View projects
Hexagonal architecture

An architectural pattern that decouples core business logic from external systems using ports and adapters to ensure painless testing and swap-ready infrastructure.

Created by Alistair Cockburn in 2005, Hexagonal Architecture (also known as Ports and Adapters) isolates an application's core domain logic from outside influences like databases, user interfaces, and third-party APIs. By defining strict boundaries through ports (interfaces) and adapters (implementations), developers can write pure, technology-agnostic business rules that remain completely testable in isolation. This setup means you can swap a PostgreSQL database for MongoDB, or replace a REST API with a gRPC CLI, without touching a single line of your core application logic.

https://alistair.cockburn.us/hexagonal-architecture/

View projects

Agentic Spagetti Code Prevention

Related talks