The AI developer bubble is going to pop soon - Shape Devlog

SUMMARY

Developer shares day 5 devlog on refactoring "Shape" app into use cases, praises Google's Antigravity over Cursor for autocomplete, and predicts AI developer bubble pop, valuing human coding skills.

STATEMENTS

The developer is refactoring the entire app into a single file structure using use case classes to simplify dependencies and improve clarity.
Use cases are single-purpose classes with an execute method returning a result object, preferred over try-catch for object-oriented error handling.
Refactoring the file service into individual use cases like upload encrypted chunk eliminates code smells from overloaded services with excessive dependencies.
Consolidating multiple entity models (e.g., paper, comment, folder) into a single server and client entity with generics reduces complexity and enables unified querying.
A new remote query system using predicates and logical operators allows complex entity fetches without separate endpoints, similar to but simpler than GraphQL.
AI tools like Codex often produce functionally correct but architecturally flawed code, failing human scrutiny in style and composability.
Google's Antigravity offers superior autocomplete, generating 50-100 lines thoughtfully, unlike Cursor's limited five-line suggestions using an in-house model.
The AI developer hype bubble will pop in 1-2 years due to accumulating technical debt, leading to job losses short-term but skyrocketing demand for skilled coders.
Software is an approximation of human intent, and adding AI as a middle layer introduces further lossy approximations, losing critical details.
Coders who learned before 2022 will be highly valued post-bubble, as younger generations skip traditional coding amid AI hype.

IDEAS

Refactoring sprawling services into bounded use cases reveals exact dependencies, making code intent crystal clear at a glance.
Single-file consolidation for related models like entities challenges conventional "one export per file" rules for streamlined development.
A predicate-based query builder reinvents flexible data fetching without GraphQL's overhead, enabling complex filters in a modular way.
AI code generation passes tests but introduces subtle architectural mismatches, like unnecessary abstract classes in a use-case paradigm.
Antigravity's deliberate slowness in autocomplete fosters deeper suggestions, prioritizing quality over speed in code completion.
The AI developer bubble stems from overhyping autonomous code writing, ignoring AI's statistical token prediction lacking true understanding.
Human coders think in code symbols, while AI approximates via English prompts, creating layered approximations that erode precision.
Post-bubble, pre-2022 coders become "chosen ones" as technical debt from AI-generated code demands expert human intervention.
Developers may revert to traditional autocomplete tools once AI hype fades, valuing reliable, context-aware assistance.
Even flawless AI engines can't eliminate lossy translation from human vision to code without direct human coding involvement.

INSIGHTS

Architectural simplicity through use cases not only bounds functionality but also enhances reusability and reduces accidental complexity in large codebases.
AI's emergent capabilities mimic reasoning but fundamentally rely on statistical patterns, underscoring the irreplaceable role of human symbolic intent in software creation.
Hype-driven adoption of AI tools risks generational skill gaps, positioning early coders as premium assets in an inevitable correction of market expectations.
Query unification across entity types streamlines backend design, proving that abstraction layers can simplify without sacrificing query power.
Code as an approximation amplifies with AI intermediaries, highlighting why direct human coding preserves nuanced vision better than prompted generation.
Selective AI use, like for ideation but not implementation, balances productivity gains against the pitfalls of unscrutinized outputs.

QUOTES

"A use case can only have one function called execute and it returns a result object. The result is I like it better than try catch because it's more object-oriented."
"It's just so beautiful. Look at it. It's so clean. I mean if I wanted to I could split this in separate files but I thought you know why not?"
"The AI developer hype bubble of like AI writing all our code and humans not having to review it, that's going to pop and that's going to be painful."
"Software is an approximation of intent. It's an approximation of a vision a product manager or entrepreneur has in their head and then they translate it to code."
"If you can code, it's going to be really val. And actually, the 20-year-olds right now are not learning how to code because they're too busy like vibing."

HABITS

Manually refactoring services into use cases by hand to ensure architectural purity, avoiding AI for critical structural changes.
Using separate Git worktrees for refactors to isolate experimental changes without disrupting the main branch.
Testing AI tools like Antigravity for autocomplete during routine tasks but falling back to manual coding for precision.
Consolidating models into single files to maintain overview, even if it bends export rules, for faster iteration.
Periodically delegating minor code combinations to AI like Codex but rigorously reviewing and rewriting for consistency.

FACTS

Antigravity's autocomplete, likely powered by Gemini models, generates up to 100 lines after 10 seconds of thinking, far surpassing Cursor's five-line limit.
The developer plans to delete hundreds of files post-refactor, collapsing 15 entity types into one generic model.
AI outputs from Codex often create abstract classes or workflows that mismatch existing patterns, despite passing functional tests.
Pre-2022 coders may command higher pay in 1-2 years as AI-induced technical debt overwhelms non-coding youth.
Software development involves translating abstract visions into code, already a lossy process before AI adds English-to-code approximation layers.

REFERENCES

Google's Antigravity: Superior autocomplete tool compared to Cursor, used for code generation in refactoring.
Cursor: Fork of VS Code with in-house autocomplete model, criticized for poor performance.
Codex and Claude: AI coding assistants that produce testable but stylistically flawed code.
GraphQL: Mentioned as a reinvented concept in the new remote query system for entity fetching.

HOW TO APPLY

Identify code smells in services by examining constructor dependencies; if over 5-10, break into single-purpose use cases.
Define use cases with an execute method returning a Result object wrapping success or error, injecting only necessary dependencies.
For file handling, separate concerns like URL requests, chunk encryption, and persistence into distinct use cases for reusability.
Unify entity models by creating generic server/client types with content variants, then build predicate queries for flexible fetching.
Test AI autocomplete tools on non-critical extractions first; manually refine outputs to align with project architecture like use-case patterns.

ONE-SENTENCE TAKEAWAY

AI hype will crash, elevating skilled human coders who master clean architectures over automated approximations.

RECOMMENDATIONS

Prioritize manual refactoring for core architecture to avoid AI-induced inconsistencies in code style.
Experiment with slower, thoughtful autocomplete like Antigravity to improve code quality during development.
Learn coding fundamentals now, as pre-AI expertise will become scarce and highly compensated post-bubble.
Design unified query systems early to simplify data access across evolving entity types.
Review all AI-generated code under human scrutiny, focusing on intent alignment beyond functional tests.

MEMO

In the frosty chill of a January morning, a developer hunkers down in "refactor hell," transforming the sprawling codebase of his app, Shape, into a paragon of simplicity. Gone are the monolithic services bloated with dependencies; in their place, elegant use cases—single-class wonders each bound to one execute method and a tidy Result object. This isn't mere tidying; it's a philosophical pivot, ensuring every line whispers its intent without the fog of hidden interactions. As snow flurries loom outside, the coder consolidates 15 disparate entity models into a singular, generic structure, paving the way for a unified entities endpoint that queries with predicate precision, echoing GraphQL's power but shorn of its excesses.

Yet amid this manual labor, doubt creeps in about AI's role. Tools like Cursor falter with their meager autocomplete, spitting out mere snippets that feel half-baked. Enter Google's Antigravity, a sluggish but sagacious alternative that ponders for seconds before unleashing 50 to 100 lines of coherent code. The developer demos it tentatively, extracting file upload logic into use cases, marveling at its depth even as navigation lags. But when he hands a minor task to Codex—merging duplicate functions—it births an awkward abstract class, a stylistic misfit in his use-case utopia. Functionally sound, perhaps, yet it underscores a deeper truth: AI excels at syntax but stumbles on soul.

This leads to a stark prophecy. The AI developer bubble, fueled by visions of code-writing machines freeing humans from drudgery, teeters on collapse. In one to two years, the developer warns, technical debt from unvetted AI outputs will avalanche, staggering teams with incoherent sprawl. Short-term job losses loom for those banking on automation, but demand for battle-hardened coders—those who learned before 2022's hype—will surge. Younger generations, seduced by "vibing" over variables, risk obsolescence. Software, after all, is intent approximated in code; layering AI's English-to-tokens haze only dilutes the vision further, turning precision into probabilistic guesswork.

Still, hope glimmers in selective symbiosis. The coder envisions offloading client updates to AI once his engine solidifies, integration tests passing like a baton. But he insists on human oversight, reasoning that true flourishing in tech demands coders who bridge abstract dreams to robust reality. As the devlog wraps, the workspace hums with promise: a leaner Shape, wiser tools, and a reminder that in the code's quiet logic, human ingenuity endures.