Google Engineer on AI Agent Pitfalls in DevTools: From Spaghetti Code to Rust Refactoring
Google engineer Lalit Maganti spent three months and ~250 hours developing syntaqlite—a suite of SQLite tools: parser, formatter, linter, and LSP server. The first approach with full delegation to Claude led to unmanageable code that had to be scrapped. Switching to Rust with AI as autocomplete produced a working 0.1 release.
First Iteration: Delegating to AI and Code Chaos
Maganti started with maximum automation: Claude designed and implemented, while the author acted as manager. In a month, they created:
- Parser in C.
- Formatter.
- Web interface.
- 500+ tests.
The result worked functionally, but the review revealed issues:
- Functions scattered chaotically across files.
- Modules grew to thousands of lines.
- The pipeline for extracting code from SQLite sources became incomprehensible even to the author.
The codebase turned into 'spaghetti'. Solution: complete teardown and restart.
Second Iteration: Rust, Manual Design, AI Autocomplete
Switching the stack to Rust, Maganti took architecture into his own hands. Claude was used for code generation based on precise specs with strict reviews.
Key practices:
- Automated tests: A driver checked every SQL query against 1390 upstream SQLite tests, comparing with the syntaqlite parser.
- Constant refactoring: Every change underwent manual review.
- Journaling: A journal (~4000 words), session transcripts, commit history.
The core was assembled in February, with 0.1 release in mid-March. The project, which had been maturing for 8 years, was implemented as a side project.
AI Agent Pitfalls: From Addiction to Loss of Control
Maganti compares working with Claude to a slot machine:
- 'One more prompt' dragged on into the night.
- Fatigue reduced prompt quality.
- Losing the 'feel' for the codebase turned him into a manager over someone else's code.
Communication broke down: vague descriptions led to wrong interpretations. AI excels at function/class level but struggles with architecture, API design, and project context.
Key Takeaways
- AI boosts implementation, but doesn't replace design: models lack 'taste' and history.
- Full delegation leads to unmanageable code: manual review is essential.
- Rust + AI autocomplete beats C + agent: architecture is key.
- Testing on upstream tests is critical for SQLite parsers.
- Journaling speeds up iterations: publish journals instead of one-shot stories.
Recommendations for Mid/Senior Devs
- Use AI for routine tasks: autocomplete, refactoring small parts.
- Retain control over architecture: models don't grasp long-term context.
- Implement automated pipelines: compare against reference tests (SQLite upstream).
- Log sessions: analyze prompts, commits, errors.
Maganti's approach shows: AI accelerates side projects, but demands discipline. Syntaqlite is an example of balancing human and agent in complex DevTools.
— Editorial Team
No comments yet.