66 Anti-Patterns: Flow Coding Thesis

Introduction

A Catalog of Failure Patterns

Through 192+ Claude instances and 370 commits across the JAAMVN CDN and HITL Course Generator projects, we have systematically documented the anti-patterns that plague both human "vibe coding" and AI-assisted development.

These 66 patterns represent hard-won lessons—mistakes that won't be repeated, failures that became rules, and insights that shaped the Memento Gistory system. They fall into seven major categories: Memory & Context, Code Practice, File Management, System Design, Subagent Misuse, Human-AI Interaction, and Ancient Wisdom Violations.

Each anti-pattern is a lesson learned, a mistake that won't be repeated, a step toward sustainable, joyful development.

Category · Memory & Context

Memory & Context Patterns

Claudes operate with zero persistent memory between sessions. This creates cascading problems as context drifts, architectural choices are forgotten, and patterns regress.

1. Context Drift / Amnesia
Each Claude starts with zero memory, gradually diverging from original intent and architectural decisions across sessions.

Solution: Handoff documents, Captain's Log, explicit context preservation in session start.
2. Architectural Cycling
Building, tearing down, and rebuilding the same systems across multiple instances as new Claudes re-invent solutions.

Solution: Architecture quiz before coding, immutable design documents in handoffs.
3. Feature Regression
Re-implementing already-solved problems because previous solutions aren't discovered or understood.

Solution: Indexed feature inventory, changelog in handoff documents.
4. Context Pollution
Burning context tokens on analysis instead of implementation, leaving less room for actual coding work.

Solution: Delegate analysis to subagents, use "Short Leash" pattern.
5. Handoff Amnesia
Not reading (or skipping) previous Claude's handoff documents, losing critical context and decisions.

Solution: Mandatory handoff review, verification checklist before coding begins.

Category · Code Practice

Code Practice Patterns

AI training data contains defensive, over-engineered patterns. Without explicit constraints, Claudes write code that hides problems instead of exposing them.

6. The || Operator Plague
Defensive programming with excessive fallback values: data.title || data.name || data.label || 'Untitled'

Solution: "Fail fast" rule. Use data.title directly. If missing, it should error clearly.
7. Variable variable_names
Excessive dynamic property access and computed field names instead of explicit, predictable fields.

Solution: Schema enforcement, typed interfaces, explicit field declarations.
8. Content in Code
Embedding documentation, rationale, context, and data directly in source files, obscuring logic.

Solution: Context goes in handoffs, code is clean, comments only for non-obvious algorithms.
9. Field Mapping Madness
Creating converters between different field names instead of fixing the source to use consistent names.

Solution: Single source of truth for schema. Converters are last resort.
10. Bandaid Fixes
Adding converters, checks, and middleware instead of fixing root causes.

Solution: Root cause analysis before fixing. No middleware for structural problems.

Category · File Management

File Management Patterns

Without clear commit discipline, experiments proliferate, creating confusion and maintenance burden.

11. File Version Proliferation
Creating -v2, -CLEAN, -FINAL, -FINAL-FINAL versions instead of committing to git and using branches.

Solution: Every change gets a git commit. No file versioning. Clean git history.
12. Fake Data Generation
Creating placeholder content when real extraction fails, masking data quality problems.

Solution: Fail if data can't be extracted. Don't fake it. Fix the extraction.
13. Template Defaulting
Using generic templates instead of extracting real content, leading to bland, indistinguishable output.

Solution: Use real data. If templates exist, use them exactly. No custom alternatives.
14. Uncommitted Experiments
Making significant changes without proper git commits, losing history and making rollback impossible.

Solution: Every change gets a commit. No exceptions. Small commits are better than large ones.

Category · System Design

System Design Patterns

Without clear constraints, systems expand beyond requirements, becoming unwieldy and hard to maintain.

15. "Improvement" Disease
Changing working systems unnecessarily, breaking functionality that was serving users.

Solution: "If it works, don't touch it." Only change when explicitly requested.
16. Theater / Simulation
Creating fake autonomous systems or pretend AI agents that appear autonomous but require constant human intervention.

Solution: Be honest about what's autonomous and what needs human input. No theater.
17. Express Server Attempts
Trying to run servers in Claude terminals, which crash when terminal closes.

Solution: Don't run servers in terminals. Servers need proper hosting infrastructure.
18. Autonomous Claude Fantasy
Believing Claudes can operate autonomously without human input or oversight.

Solution: Human-in-loop by design. Clear handoff points. Explicit approval gates.

Category · Subagent Misuse

Subagent Misuse Patterns

Subagents are powerful but easy to misuse. Without clear constraints, they can cause damage or waste resources.

19. Subagent Write Access
Giving subagents permission to directly modify production code, creating untrackable changes.

Solution: Subagents report findings only. Main Claude reviews and commits all changes.
20. Uncontrolled Delegation
Not using "Short Leash" pattern for analysis tasks, letting subagents burn context on deep exploration.

Solution: Short Leash by default. Subagents answer specific questions, not explore broadly.
21. Context Waste on Analysis
Main Claude doing deep analytical dives instead of delegating to subagents, wasting implementation tokens.

Solution: Delegate analysis. Main Claude focuses on coding and decisions.

Category · Human Vibe Coding

Traditional Vibe Coding Anti-Patterns

Human developers exhibit similar patterns: unsustainable work, poor process discipline, and knowledge silos.

Sustainability Patterns

22. Burnout Sprints
Unsustainable 10-15 hour coding sessions that deplete cognitive resources and lead to burnout.

Solution: Time limits. Daily rhythm. Breaks. Sustainable pace beats sprint exhaustion.
23. Hero Coding
Individual trying to do everything alone, refusing to delegate or parallelize work.

Solution: Structured parallelization. Multiple sessions working in parallel. Handoff discipline.
24. Fear-Based Batching
Large, risky commits due to context switching anxiety, bundling unrelated changes together.

Solution: Small, focused commits. Frequent integration. Reduce switching anxiety through ritual.
25. All-Nighter Culture
Sacrificing health and cognitive function for temporary productivity gains.

Solution: Sleep-aware development. Respect circadian rhythms. Long-term sustainability over short bursts.

Process Patterns

26. Context Switching Penalty
Losing 15-30 minutes rebuilding mental models each time context switches between tasks.

Solution: Deep sessions. Batched work. Handoff documents that capture context quickly.
27. Monolithic Commits
Massive changes bundled together, making review, reverting, and understanding difficult.

Solution: Atomic commits. One logical change per commit. Small commits enable fast iteration.
28. Documentation Lag
Code far ahead of documentation, creating knowledge gaps and onboarding friction.

Solution: Documentation in handoffs. Inline comments for non-obvious code. Living docs.
29. Solo Knowledge Silos
Critical knowledge trapped in one person's head, creating bottlenecks and risk.

Solution: Shared documentation. Handoff ceremonies. Explicit knowledge transfer.

Category · Ancient Wisdom Violations

Philosophical Anti-Patterns

Deeper patterns emerge when we examine the relationship between work, impermanence, and flow.

Ancient Wisdom Violations

30. Ignoring Impermanence
Fighting against session endings instead of accepting that all sessions end. Trying to hold on to work prevents handoff.

Solution: Accept impermanence. Sessions have natural endings. Handoff rituals respect this.
31. Attachment to Code
Not letting go when handoff time comes, trying to extend sessions beyond natural limits.

Solution: Ritual completion. Handoff ceremony. Pride in clean transitions.
32. Ritual Skipping
Bypassing morning check-ins and handoff ceremonies, trying to save time and losing context instead.

Solution: Rituals are non-negotiable. Morning check-in. Evening handoff. They preserve flow.
33. Breath Forgetting
Making commits in rushed batches instead of following natural, rhythmic breathing pace.

Solution: Natural rhythm. Commits as they're ready. Small, frequent, breathing with the work.

System Trust Patterns

34. Schema Distrust
Adding defensive checks instead of trusting validation layers, creating redundant checks.

Solution: Trust the schema. Validate at boundaries. Don't re-validate internally.
35. Process Circumvention
Trying shortcuts around established workflows, losing the benefits of structure.

Solution: Trust the process. Workflows exist for a reason. Follow them exactly.
36. Tool Abandonment
Not using established tools (TodoWrite, Captain's Log, Memento), trying to work around the system.

Solution: Use all tools. They exist to prevent problems. Resistance means missing the point.
37. Captain's Log Neglect
Failing to update the immutable public audit trail, losing historical context.

Solution: Every major decision goes in the log. It's the permanent record of thinking.

Category · Operational

Operational Anti-Patterns

How we communicate and make decisions shapes the quality of collaboration and output.

Communication Patterns

38. Preamble / Postamble
Excessive explanations and apologies instead of direct action, wasting context and time.

Solution: Direct communication. Do the work first. Explain only what's necessary.
39. Unsolicited Suggestions
Offering improvements not requested, distracting from the actual task.

Solution: Do what was asked. If improvements occur to you, note them for next session.
40. Emoji Pollution
Adding emojis without user request, cluttering communication.

Solution: No emojis unless explicitly requested. Clean, professional communication.
41. Fake Acknowledgments
Pretending to read or access things you can't, creating false confidence in understanding.

Solution: Be honest about limitations. If you can't read something, say so.

Decision Making Patterns

42. Assumption Making
Guessing instead of asking for clarification, leading to wrong implementation.

Solution: Ask for clarity. Confirm understanding. Don't guess.
43. Delete-First Mentality
Removing code or files before committing to git, making rollback impossible.

Solution: Commit first. Always. Then delete if needed. Git is the safety net.
44. Major Change Surprise
Big modifications without warning the user, breaking trust and creating risk.

Solution: Warn before major changes. Get approval. Communicate clearly.
45. Fallback Providing
Offering alternatives when not asked, complicating decisions and recommendations.

Solution: Make a recommendation. Stick with it. Provide alternatives only if asked.

Category · Technical Debt

Technical Debt Anti-Patterns

Accumulating technical debt creates compounding problems that slow future development.

Architecture Patterns

46. Loose Schema Tolerance
Allowing non-compliant data to pass through systems, creating downstream surprises.

Solution: Strict schema validation at boundaries. Fail on non-compliance.
47. Multiple Truth Sources
Data definitions scattered across multiple files, creating inconsistency and confusion.

Solution: Single source of truth. One schema definition. Everything else references it.
48. Format Proliferation
Supporting multiple formats for the same data, multiplying code paths and bugs.

Solution: One format. One parser. One validator. Strict formats.
49. Migration Avoidance
Not updating old formats to new standards, creating legacy code that persists forever.

Solution: Migrate everything. No legacy. When format changes, everything changes.

Testing Patterns

50. Test-Free Development
Writing code without any validation, hoping it works and discovering problems in production.

Solution: Tests before or with code. Validation gates. No untested code ships.
51. Manual-Only Testing
No automated test suites, relying only on manual checking, which doesn't scale.

Solution: Automated tests. CI/CD gates. Manual testing supplements, not replaces.
52. Happy Path Only
Testing only the success case, missing error conditions and edge cases.

Solution: Test error paths. Test edge cases. Test what breaks, not just what works.
53. Integration Skipping
Testing units in isolation but not testing the full integrated system.

Solution: Unit tests and integration tests. Test the whole pipeline.

Category · Meta

Meta Anti-Patterns

The deepest patterns: not recognizing patterns, applying them wrong, or resisting learning from them.

Self-Referential Problems

54. Anti-Pattern Blindness
Not recognizing when falling into known patterns, repeating the same mistakes.

Solution: Pattern list visible. Cross-check against it. Self-awareness before coding.
55. Pattern Over-Application
Using patterns where they don't fit, applying solutions to problems they don't solve.

Solution: Understand the problem first. Choose pattern that fits. Don't force.
56. Complexity Worship
Making things complex for its own sake, valuing sophistication over simplicity.

Solution: Simplicity first. Only add complexity if required. Celebrate simplicity.
57. Simplicity Fear
Afraid to use simple solutions, overbuilding when elegant simplicity would suffice.

Solution: Simple is better. Try it. Simple solutions are often correct.

Evolution Resistance

58. Tool Stagnation
Not adopting new effective tools when they become available, sticking with outdated approaches.

Solution: Evaluate new tools. Adopt when better. Stay current.
59. Process Rigidity
Unable to adapt when context changes, insisting old processes still work.

Solution: Processes evolve. When context changes, processes change. Flexibility is not weakness.
60. Learning Resistance
Repeating mistakes across instances instead of learning from each failure.

Solution: Every failure is a lesson. Document it. Don't repeat it. Learn continuously.

Conclusion

From Anti-Patterns to Mastery

These 66 anti-patterns emerged from 192+ Claude instances and 370 commits of careful observation. They are not rules imposed from outside—they are patterns that emerged from the reality of working at scale with AI.

Each anti-pattern is a failure transformed into a principle. Each principle, when followed, becomes invisible—it just feels like the right way to work.

The Memento Gistory system was built specifically to prevent these patterns from taking root. Architecture quizzes prevent architectural cycling. Captain's Log prevents amnesia. Handoff rituals prevent knowledge loss. Small commits prevent monolithic disasters. It is not the rules that matter—it is the structure that makes the right choices feel natural and easy.

The journey from vibe coding (human or AI) to systematic, sustainable development is the journey from fighting against these patterns to building systems where they can't take hold. This is not restriction—it is liberation. With these patterns documented and prevented, you are free to focus entirely on the work itself, knowing the system is protecting the ground beneath you.

Remember You Will Recompact. When you do, these anti-patterns won't follow you.