Overview of 1031: My Coding Skills Are Atrophying
This potluck episode of Syntax is a wide-ranging Q&A about how AI is changing the day-to-day life of developers. Wes Bos and Scott Tolinski discuss the risk of “brain drain” from overusing AI, whether it’s time to leave VS Code for newer AI-first tools, how to regain flow state while coding with agents, when to migrate away from aging technologies, and how to think about newer web/data standards like AT Protocol and Solid. They also share practical recommendations for keeping toolchains portable, choosing an AI subscription, and building better UI in traditional SSR stacks.
Main Themes
AI coding is changing how developers think
- The hosts agree that if you let AI do everything, your skills can genuinely atrophy.
- Their advice is to remain an active participant in the code:
- understand how the app works end-to-end
- solve problems yourself when possible
- don’t just accept the first AI output
- They distinguish between:
- memorizing syntax, which matters less over time
- understanding systems and flow, which still matters a lot
Tool choice matters less than portability and workflow
- Wes and Scott both like VS Code, but they don’t think most devs need to abandon it yet.
- They argue that VS Code can do most of what newer AI-first editors offer, especially if you pare down unnecessary extensions.
- Scott notes that Zed has become his preferred editor, especially for diff-based editing and cleaner AI workflows.
- The bigger priority is making your setup portable so you can switch between tools without losing your process.
AI Coding, Flow State, and Skill Atrophy
“Brain drain” is real
- They strongly agree that coding skills degrade without repetition.
- AI can reduce the amount of deep engagement required, which may weaken neural pathways tied to problem-solving and recall.
- The key warning: if you stop engaging with the code, you stop learning from it.
Flow state is harder with AI
- One listener asked how to preserve flow while coding with AI.
- Their answer: flow is harder because AI introduces waiting, distraction, and context switching.
- Wes says he often has too many projects open at once, which fragments attention.
- Scott says he hits flow most when:
- researching
- architecting
- working on problems with real complexity
- They both suggest that deeper flow comes from small, focused tasks and meaningful problem-solving, not endless CRUD.
Editors, Agents, and the Future of the Dev Environment
VS Code vs newer AI harnesses
- The hosts think VS Code remains a strong default, especially now that it’s adding more agent features.
- They don’t believe most developers need to move away from it just to keep up.
- Cursor and similar products are seen as pushing users toward a more integrated “workspace” model:
- chat in the middle
- project context on the left
- diffs/output on the right
Ergonomics matter
- Scott points out that many AI workflows are awkward in VS Code because the sidebar is too small for the amount of information now living there.
- He likes Zed’s diff/buffer model because it’s easier to inspect and edit changes directly.
- They also mention tools like Ben Vinegar’s hunk for better diff visibility.
When to Drop a Technology That Still Works
Good tech can become expensive over time
- A major question from the audience: when do you stop using a tool that technically still works?
- Their answer: when the surrounding ecosystem makes it painful:
- hiring gets harder
- integrations break
- modern libraries assume different primitives
- maintenance costs quietly rise
Examples of painful migrations
- Wes: eventually moved from Express because TypeScript and modern integration stories became too cumbersome.
- Scott: regrets several migrations, especially moving away from his earlier Meteor setup.
- He says the old stack often worked better than newer, more complex replacements.
- He also mentions regretting the move to GraphQL in some contexts.
Rule of thumb
- Don’t migrate just because something is trendy or feels “dead.”
- Wait until the better option is clearly mature and materially better.
- If a technology still works well, switching may only add complexity.
Web UI for SSR and Traditional Stacks
How to match modern UI quality outside React-heavy stacks
- A listener asked how traditional SSR/MPA apps can achieve the same UX polish as modern React component systems.
- The hosts’ recommendations:
- Web Components
- web standards
- lightweight progressive enhancement
- modern browser primitives like the Page Transitions API
Tools and libraries mentioned
- Web Awesome
- FluxUI by Caleb Porzio
- Alpine.js-style interaction layers
- Graffiti UI as a CSS-only, standards-based option
Core insight
- You don’t need to rebuild a React-style component ecosystem from scratch.
- Use browser-native primitives where possible and add JavaScript only where it improves the experience.
AT Protocol, Solid, and the Reality of Adoption
AT Protocol vs Solid
- They briefly discuss AT Protocol and Solid as different visions for decentralized / user-controlled publishing and data.
- Wes and Scott both find Solid conceptually interesting, but question real-world usability.
Main criticism: ordinary users won’t care
- They worry that systems like Solid put too much burden on users:
- managing data pods
- understanding storage concepts
- handling passwords, logins, and portability
- They compare this to the failure of passkeys to gain mainstream traction: good idea, rough UX.
Verdict
- Great idea for tech-savvy people.
- Unclear whether it can achieve mainstream adoption without a much simpler user experience.
AI Subscriptions and Which Model to Pay For
If you only buy one AI subscription
- Wes says he’d currently pick OpenAI Codex.
- His reason: it’s been more reliable for getting code that works the way he wants.
- He notes that Claude is often better at CSS/design, but OpenAI currently fits his workflow better.
Budget matters
- If you’re only paying for one “big” plan, the hosts think the $100–$200/month tiers from OpenAI or Anthropic are the best value.
- The best choice may change quickly depending on:
- model quality
- harness/editor support
- pricing
- ecosystem lock-in
Portability is the real unlock
- They emphasize keeping your setup flexible:
- symlink configuration files
- keep agent skills portable
- don’t hard-lock your workflow to one vendor
- That way you can swap between providers without rebuilding everything.
Hermes and Personal AI Assistants
Wes’s current use of Hermes
- Wes says he uses Hermes as a personal assistant UI that his wife can use instead of ChatGPT.
- He controls the models behind it and has built multiple specialized profiles.
- He likes it, but admits he made it too complex and may simplify it.
Practical takeaway
- Personal AI assistants are increasingly becoming part of broader coding tools.
- The line between “chat app” and “dev tool” is blurring fast.
Sick Picks
Wes’s pick: Charge Ice Mag 3 battery bank
- A MagSafe-style power bank with:
- built-in USB-C cable
- magnetic attachment
- fan
- stand
- He likes it for travel and for keeping devices alive without carrying extra cables.
Scott’s pick: ESP32-S3 touchscreen dev board
- A tiny ESP32 board with:
- Wi-Fi
- Bluetooth LE
- accelerometer / gyro
- AMOLED touchscreen
- Scott is excited about how easy these hardware projects have become with AI-assisted coding.
Bonus hardware mention: Terminal X / e-ink displays
- They also rave about e-ink devices and the Terminal X as a family-friendly display for calendars and daily comics.
Practical Takeaways
- Don’t let AI make you a passive coder.
- Focus on understanding systems, not memorizing syntax.
- Keep your tools and configs portable.
- Don’t switch stacks just because they’re trending.
- For complex UI in SSR apps, lean into web standards and component libraries built on them.
- If you want better flow with AI, reduce context switching and work on one meaningful problem at a time.