# Vibe Engineering Effect Apps

Michael Arnaldi, Effectful | AI Engineer Europe 2026 | 1:43:04

Source: https://www.youtube.com/watch?v=Wmp2Tku2PrI
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/vibe-engineering-effect-apps
Published: 2026-05-07
Tags: agents, coding-agents, context-engineering

## TL;DR
- Coding agents use a library more effectively when its source code is placed in the project where the agent already looks for patterns.
- Strict diagnostics, lint rules, tests, and repository instructions create feedback that prevents agents from accepting weak code.
- Small persisted research files and fresh agent sessions give the model focused context for implementing unfamiliar features.

## Summary
Michael Arnaldi builds an Effect application from an empty repository while explaining how he works with coding agents. His main technique is simple: clone the Effect repository into the project so the agent can inspect real source code instead of relying on stale training data, documentation, or ignored dependencies. He adds strict TypeScript diagnostics, tests, formatting, lint rules, and an agents.md file that describes commands and points to the local repository. For unfamiliar features, he first asks the agent to research the source and save patterns as Markdown, then creates a separate implementation plan. The workshop produces a Todo HTTP API with SQLite persistence, OpenAPI documentation, and tests. Arnaldi also discusses fresh context windows, Ralph loops, semantic code search, and rules that ban shortcuts such as unsafe casts. He is candid that generated code still needs review and that many best practices are opinions which require human judgment.

## Key ideas
### Cloning the library gives the agent the context it was trained to use
[03:16](https://www.youtube.com/watch?v=Wmp2Tku2PrI&t=196s)
Arnaldi argues that coding agents are trained mainly to consume and produce code, so they are more likely to inspect code in the project than documentation, MCP servers, or ignored dependencies. Putting Effect in node_modules is insufficient because agents tend to focus on the application's own files. Git-ignored files can also be skipped by indexing tools. His practical answer is to clone the Effect repository into the project, then ask the agent to explore it and copy its patterns. He uses this approach across languages and in older codebases, including cloning major framework repositories before asking the agent to generate project guidance.

### LLMs need deliberate context management because they do not learn from each session
[05:59](https://www.youtube.com/watch?v=Wmp2Tku2PrI&t=359s)
Arnaldi contrasts human learning with model behavior. People retain and reorganize experience over time, while a deployed language model does not remember a project-specific instruction the next day. An interaction is an append-only conversation inside a fixed-size context window. More context can also confuse the model because everything is pushed through the same prediction process. He therefore restarts sessions to avoid context pollution and uses a simple loop that gives the agent one small task, asks it to implement that task, and then exits. In his experience, reducing the tools and information available to the model can produce better results.

### A strict project setup turns compiler feedback into pressure against bad generated code
[13:13](https://www.youtube.com/watch?v=Wmp2Tku2PrI&t=793s)
Starting from an empty repository, Arnaldi has the agent create a Bun project with source and test directories, Vitest, TypeScript, Effect beta, and the TSGo compiler preview. He configures the editor and command-line type checking, then changes every available diagnostic severity to error. The reason is specific to agent-assisted work: code with any diagnostic should fail the feedback loop rather than pass with a warning or suggestion. He also wants formatting on save, tests that exercise the runtime setup, and commands such as bun run test and bun run type check. The setup is treated as part of the programming process, not as cleanup after implementation.

### Repository instructions should evolve from observed agent mistakes
[35:20](https://www.youtube.com/watch?v=Wmp2Tku2PrI&t=2120s)
Arnaldi adds the Effect repository as a squashed git subtree under a local repos directory, then creates agents.md. The file lists available commands, explains that repos/effect contains the reference code, and tells the agent to use it for Effect practices. He expects the file to grow as the project reveals new failure modes. One early rule says the agent must never run watch-mode commands or leave a development server running, since those actions can make the agent get stuck. He also describes lint rules from his accountability repository that prohibit unsafe type assertions, any, unknown, and other shortcuts he has seen models produce.

### Research files let an agent learn only the library patterns a feature needs
[41:40](https://www.youtube.com/watch?v=Wmp2Tku2PrI&t=2500s)
Before implementing the API, Arnaldi asks the agent to inspect the Effect repository and save its findings in patterns/http-api.md. The research identifies a shared HTTP API as the preferred starting point, with OpenAPI documentation derived from it. Arnaldi does not require a committed generated client for this project. He repeats the process for persistence, asking the agent to investigate Effect SQL and SQLite and write patterns/sql.md. This selective approach matters in existing projects because importing every library pattern can push the model toward using parts of Effect that the application does not need. The pattern files can be edited later when the project's preferences differ from upstream examples.

### Spec-driven development works better with a fresh context than with restricted plan mode
[43:08](https://www.youtube.com/watch?v=Wmp2Tku2PrI&t=2588s)
Arnaldi finds plan mode less useful because it limits the model's tool access. Instead, he asks the agent to discuss a feature, save the result as a Markdown specification, and implement that specification in a later step. For the Todo API, the plan covers creating todos with a title and description, updating them, marking them done or undone, listing them, and choosing SQLite persistence. He then uses a loop of small implementation tasks and fresh sessions. The model can still read the source repository and the research files, but it does not carry unrelated prior conversation into the next task.

### Lint rules encode the corrections that an agent repeatedly needs
[1:05:07](https://www.youtube.com/watch?v=Wmp2Tku2PrI&t=3907s)
While the agent implements the SQL client and migrations, Arnaldi watches for patterns he does not want to repeat. He describes a lint rule that bans SQL type declarations because the model used them as compile-time casts without runtime validation. The preferred approach is an SQL schema. He also wants branded identifier types and validation at the API boundary, rather than converting plain strings inside handlers. When the agent creates duplicated code or an unnecessary test layer, he points it out and asks for a correction. In his workflow, each recurring mistake becomes a project rule or a new research pattern, so the same review comment does not have to be given repeatedly.

### The completed prototype shows the method can produce a usable Effect API quickly
[1:18:14](https://www.youtube.com/watch?v=Wmp2Tku2PrI&t=4694s)
The generated project ends with an HTTP server, a Todo API, an SQL client, migrations, tests, a client with a base URL, and OpenAPI documentation. Arnaldi checks the start command and opens the generated API description before cleaning up the test suite. He catches duplicated code and an unnecessarily complicated layer setup, then asks the agent to simplify it. The result is still an experiment rather than a finished production system, but it demonstrates the workflow from an empty repository to a working API without Arnaldi writing the implementation by hand. He says the same method could be used later to research Effect workflows and Effect Cluster.

## Notable quotes
- "And in reality, this session should just be called just clone the repo and get and be done with it." (03:16)
- "So how do you make it remember that is the big question." (08:07)
- "For AI we would like to turn everything into an error so that the LLM cannot accept code that has any remote resemblance or an error." (30:30)
- "At the end, the dumbest thing ever ends up working better." (44:29)
- "The zero to one problem is not really a problem for the first 10 days or 10 hours depending on what you're building." (48:27)

## Tools & references mentioned
- Effect
- Effectful
- Bun
- Vitest
- TypeScript
- TSGo
- OpenCode
- GPT-5.4
- Opus 4.5
- Effect Solutions
- Kit Langton
- accountability
- SQLite
- OpenAPI
- Temporal
- Effect Cluster
- Ralph Loops
- Joffrey Huntley
- Anthropic
- OpenAI
- ESLint

## Who should watch
- You are using coding agents in an unfamiliar TypeScript or Effect codebase and want the agent to see real library examples.
- Your generated code passes basic checks but repeatedly uses unsafe casts, weak schemas, or project-specific anti-patterns.
- You maintain a team repository where different agents need shared instructions, focused research files, and repeatable implementation workflows.

## Related talks

- [From Vibe Coding To Vibe Engineering](https://aietalks.com/talks/from-vibe-coding-to-vibe-engineering) (Kitze, Sizzy, 25:28)
- [Vibe Coding with Confidence](https://aietalks.com/talks/vibe-coding-with-confidence) (Itamar Friedman, Qodo, 20:55)
- [Vibe Coding at Scale: Customizing AI Assistants for Enterprise Environments](https://aietalks.com/talks/vibe-coding-at-scale-customizing-ai-assistants-for-enterprise-environments-i1upan6u) (Harald Kirshner, Microsoft, 15:26)
- [Vibes won't cut it](https://aietalks.com/talks/vibes-wont-cut-it) (Chris Kelly, Augment Code, 15:34)
- [Vibe Coding at Scale: Customizing AI Assistants for Enterprise Environments](https://aietalks.com/talks/vibe-coding-at-scale-customizing-ai-assistants-for-enterprise-environments) (Harold, VS Code, 1:20:38)