Vibe Engineering Effect Apps — Michael Arnaldi, Effectful

Key Concepts

• Vibe Engineering: An approach to AI development that prioritizes authenticity and "from-scratch" experimentation over rigid, pre-planned structures.
• Effect (v4): A TypeScript library for building robust, type-safe, and scalable applications, featuring advanced functional programming patterns.
• Coding Agents: AI models (e.g., GPT-4o, Claude 3.5 Sonnet/Opus) used to automate software development.
• Context Window: The fixed-size memory buffer of an LLM; managing this effectively is critical to prevent model "de-optimization" or confusion.
• RAG (Retrieval-Augmented Generation) via Repository Cloning: The strategy of cloning a library’s source code directly into the project to provide the AI with high-fidelity, context-aware documentation.
• Spec-Driven Development: Using the AI to generate a markdown-based specification (plan) before implementation to maintain focus and reduce context pollution.
• Effect Cluster/Workflows: Tools for managing long-running, persistent operations, essential for AI-driven processes that may take minutes to complete.

---

1. Main Topics and Methodology

The workshop focused on the philosophy that "just cloning the repo" is the most effective way to enable AI agents to work with complex libraries like Effect.

• The "From Scratch" Workflow: The speaker demonstrated building a project from an empty directory, initializing it with bun, vest (for testing), and TypeScript.
• Context Management: To avoid "context pollution," the speaker advocates for:
  • Restarting sessions frequently to clear the context window.
  • Using small, iterative tasks rather than one massive prompt.
  • Creating agents.md files to define project-specific rules and available commands.
• Constraint-Based Development: The speaker uses "back-pressure" (e.g., strict linting rules, banning any or unknown types, and forcing branded types) to prevent the AI from taking "lazy" shortcuts.

2. Step-by-Step Process for AI-Assisted Development

1. Initialization: Create a clean repository and install necessary tools (bun, vest, effect).
2. Context Injection: Clone the target library (e.g., effect) into a repos/ folder. This allows the AI to index the library's internal patterns as if they were part of the local codebase.
3. Pattern Extraction: Ask the AI to research specific features (e.g., HTTP APIs, SQL persistence) within the cloned repo and save these as patterns/*.md files.
4. Spec-Driven Implementation: Create a plans/ file to define the desired functionality.
5. Iterative Execution: Use a loop (or manual restarts) to implement features, using the patterns/ files as the "source of truth" for the AI.
6. Validation: Use strict linting and type-checking to ensure the AI adheres to the defined patterns.

3. Key Arguments and Perspectives

• Models are "Dumb" but Powerful: The speaker argues that LLMs do not "learn" in the human sense; they are fixed-weight models. Therefore, the developer's job is to architect the environment (the repo) so the model can "see" the right patterns.
• The "Junior Developer with a Knife" Analogy: AI models are like junior developers who are fast but prone to dangerous shortcuts. The developer must act as a supervisor, using linting rules to "babysit" the model and prevent bad practices (e.g., using as casting instead of schema validation).
• Standardization vs. Flexibility: While the speaker acknowledges the desire for standard AI patterns, they argue that patterns should be generated by the model for the specific model being used, rather than relying on off-the-shelf, one-size-fits-all prompts.

4. Notable Quotes

• "The reality is with LLMs... they are very different [from humans]. We learn continuously... with LLMs, this does not happen."
• "The zero-to-one problem is not really a problem... as programmers, if our job is not to write code, our job should be to set up the repositories in ways that the models can act good on it."
• "Why does this rule exist? Because the model did that." (On the necessity of specific linting rules).

5. Technical Insights

• Diagnostic Severity: The speaker sets all TypeScript diagnostics to error to ensure the AI cannot ignore warnings or produce "sloppy" code.
• Semantic Code Search: Used to prevent the AI from re-implementing features that already exist in the codebase.
• Long-Running Processes: The speaker highlights that AI-driven apps often have long response times (minutes vs. milliseconds), making Effect Workflows and Clustering essential to handle server crashes and ensure process completion.

6. Synthesis/Conclusion

The workshop concluded that the most effective way to leverage AI for complex library development is to treat the AI as a tool that requires a highly structured environment. By providing the AI with direct access to source code (cloning), enforcing strict patterns via markdown files, and using aggressive linting to prevent "lazy" coding, developers can successfully build complex, type-safe systems without writing code by hand. The future of this workflow lies in automating the "pattern extraction" process and using robust workflow engines to handle the inherent instability of long-running AI operations.