Overview of 1019: LGTM, Ship It: The AI Code Review Problem
This Syntax Potluck episode covers a wide-ranging set of developer questions, with a heavy focus on AI-assisted coding, code review at scale, local AI models, version control alternatives, and framework/library tradeoffs. Wes Bos and Scott Tolinski largely agree that AI can accelerate development, but it also amplifies old software engineering problems like technical debt, duplicated logic, and poor architecture if teams don’t enforce strong standards.
AI-Generated Code: How to Understand and Control It
A listener asked how to better understand large code blocks written by AI before making changes.
Key advice
- Use inline comments: Have the AI generate terse comments so the code reads more like plain English.
- Impose strict rules in prompts: Tell the AI how to structure components and what patterns to avoid.
- Be especially strict in UI code: AI often overuses side effects and creates overly complex component logic.
- Prefer smaller, more deliberate changes for UI work rather than asking for large, opaque features.
- Create shared utilities globally and instruct the AI to check existing helpers before making new ones.
Main takeaway
The AI’s output becomes much easier to review when you force consistency upfront. The less freedom the model has to invent architecture, the more readable its code will be.
The AI Code Review Problem: Speed vs. Quality
One question described a team merging dozens of PRs per developer per week with little meaningful human review.
Core concerns raised
- The bottleneck is no longer generating code; it’s reviewing and validating it.
- Large AI-driven PR volume leads to:
- technical debt
- duplicate implementations
- architecture drift
- fragile codebases
- recurring bugs
- AI makes it easy to add code and hard to remove it.
Wes and Scott’s perspective
- This is not a new software engineering problem — AI just makes it happen much faster.
- The same fundamentals still matter:
- good standards
- linting
- tests
- clear architecture
- disciplined prompts
- Teams should not confuse “more output” with “better software.”
Local AI Models: What They Actually Are
A listener asked for a clear definition of local models.
Definition
A local AI model is one that runs on your own machine, not through a remote API.
Important distinction
- Running a tool locally does not necessarily mean the model itself is local.
- If it makes API calls to a cloud service, it’s still remote.
Where local models make sense
- Purpose-built tasks like:
- toxicity detection
- speech-to-text
- text-to-speech
- tagging/categorization
- vectorization
- Browser-based and smaller model ecosystems were mentioned, including:
- Transformers.js
- Hugging Face models
- MediaPipe-style computer vision models
Main takeaway
Local AI is powerful, but it is not a magic replacement for frontier models. It shines when the task is narrow and well-defined.
Git Alternatives, Jujutsu, and the Future of Version Control
The hosts discussed Jujutsu (jj) and why some developers are excited about it.
What stood out about jj
- It is fully Git-compatible
- It uses an operation log instead of traditional Git concepts
- It offers:
- easy undo
- no staging
- automatic rebasing
- “bookmarks” instead of branches
Cautionary note
- Wes and Scott both noted they haven’t used it enough to fully endorse it.
- Some developers love it; others find the mental model too different from Git.
- The real next-gen version control system may need to be built for agents, not humans.
Related frontier
- They mentioned Zed’s Delta DB, a version control concept designed around fine-grained changes and agent collaboration.
- The broader idea: modern tooling may need to capture every small operation, not just final snapshots.
Freelancers and Contractors: How to Price Work in the AI Era
A listener asked how to price work fairly when AI reduces build time.
Answer
- Price based on value delivered, not time spent.
- Hourly billing only makes sense in certain arrangements, like ongoing support or retainer-style work.
- AI should not change the basic principle:
- clients pay for outcomes
- not for how long it took you to achieve them
Extra observation
- AI may change market expectations and reduce what people are willing to pay for simple work.
- But the pricing model should still be tied to impact, not token counts or raw labor.
WebKit Box Reflect: Why It Never Became Standard
A question came up about -webkit-box-reflect.
Explanation
- It was a Safari-only visual effect for glossy reflections.
- It never became broadly standardized because:
- it was very trendy and time-specific
- it had limited practical value
- browsers tend to avoid adopting niche, flashy features that don’t generalize well
Takeaway
It’s a relic of an older web aesthetic, more useful now as a CSS curiosity than as a modern production feature.
Angular, External Libraries, and the Cost of Dependencies
A frontend developer working in Angular asked whether their team should rely more on external libraries.
Wes and Scott’s view
- Angular’s opinionated ecosystem naturally encourages using built-in tooling.
- Pulling in external libraries always has a cost:
- maintenance
- long-term dependency risk
- version drift
- abandoned packages
- In the age of AI, relying on fewer dependencies can actually be a strength because AI can help generate small, local utilities when needed.
Main takeaway
The team’s caution is valid. “Just install a library” is not always the best answer, especially if you’ll be maintaining that dependency for years.
Sick Picks
Wes’s pick: Upgraded Bose QC35 headphones
- He recommended his 10-year-old Bose QC35s
- He refreshed them with:
- new ear pads
- a USB-C charging board conversion from QC45 parts
- Result: still his favorite noise-canceling headphones, even years later
Scott’s pick: Reachy Mini robot from Hugging Face + Pollen
- A small build-it-yourself robot with:
- Wi‑Fi
- cameras
- microphones
- speakers
- motors
- It can connect to AI providers and run custom apps
- Scott plans to use it for:
- kids’ spelling practice
- a Hermes-powered conversational setup
- Warhammer 40K assistance
- The robot also highlights how computer vision models like MediaPipe can run on low-power hardware
Bottom Line
This episode reinforces a familiar Syntax theme: AI is a force multiplier, not a replacement for software engineering discipline. The hosts repeatedly come back to the same fundamentals — strong conventions, careful architecture, minimal unnecessary dependencies, and thoughtful review — because those are what keep AI-generated speed from turning into long-term chaos.