AI Engineer Europe 2026

Vibe Engineering Effect Apps

Loading slides…

Read the talk

Vibe Engineering Effect Apps

Build a local todo API from an empty repository by giving a coding agent dependency source, durable pattern files, and checks that make shortcuts harder to accept.

From a talk by Michael Arnaldi

Before you start: Familiarity with TypeScript, package scripts, HTTP APIs, and basic database testing will help; prior Effect experience is not required.

How does an agent discover the right patterns?

The workshop starts without a prepared application. Michael Arnaldi opens the discussion to a mixed audience: one attendee already runs Effect v4 in production against advice; others know functional programming or coding agents but have little Effect experience. One attendee has converted a Promise-based API client to Effect and built a CLI on top. The next problem is discovery: how do you make Effect’s patterns available to the agent implementing your application? That attendee wants the library’s safety properties without letting agents become loose cannons, but is unconvinced that adding its repository as a subtree is the answer.

Arnaldi’s answer is deliberately direct: “Just clone the fucking repo.” His experience comes largely from library development, including complex TypeScript type machinery and Rust. Library work requires attention to how other programmers will use an abstraction; application work reaches the same territory when it generalizes repeated patterns. He had expected AI to be more useful for applications, yet reports that he has stopped writing code by hand even for libraries. Some of those codebases have neither documentation nor established practices online. A documentation server cannot retrieve guidance that does not exist. The source has to supply it.

0:221:22
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:22 · section reference included

Put knowledge where the agent will look

A conversation does not continuously retrain a model. Arnaldi contrasts human experience becoming long-term memory with pretraining and post-training, using compilation success and failure as examples of feedback for coding models. An instruction given today does not automatically become something a fresh session knows tomorrow. The useful working model is a bounded array of messages: the context window. Adding unrelated work to that array can make later tasks harder, even when there is space left.

He illustrates the limits with million-token windows, knowledge months out of date, and hypothetical models with trillions of parameters. These are arguments for supplying current evidence, not specifications of the model running the workshop. Stored knowledge is compressed; useful generalization still needs the right inputs. Arnaldi reports six to eight months of agent-assisted work without writing code by hand, so the practical question is how to arrange those inputs.

His method is to make the dependency look like another part of the project. A local Effect checkout gives the agent implementations, tests, examples, and repeated conventions to explore progressively. He attributes the method’s effectiveness to coding agents’ experience consuming and producing code. The agent need not ingest the whole dependency at once; it can find the files relevant to the current feature and copy their patterns.

Source locationDiscovery concern
node_modulesArnaldi observes less agent attention to installed dependencies.
Gitignored directoryIndexing may omit the reference source.
Tracked project directorySource can be explored alongside application code.

Harness behavior matters here. Cursor’s ignore documentation supports the indexing distinction: Git ignore rules affect indexing, and node_modules is excluded by default. Indexing exclusions are not proof that a model was trained to avoid a path, nor are they a universal restriction on terminal access. Arnaldi’s practical recommendation is to remove the discovery obstacle by keeping the reference repository visible.

5:596:33
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:59 · section reference included

Establish a checked baseline

The application target is a Bun project with Vitest, TypeScript checking, an HTTP API, OpenAPI documentation, and a typed client. If time permits, it will extend into persistent operations through workflows and clustering. Arnaldi asks GPT-5.4, running in OpenCode, to create the initial setup.

He began this style of development with Sonnet 4, which he likens to a child running through a house with a knife—an analogy he attributes to Geoffrey Huntley, whose Ralph loop returns later in the workflow. He finds Opus 4.5 and GPT-5.4 much more capable. Arnaldi estimates that open-weight models trail frontier models by three to six months, without naming a benchmark or predicting when they will meet his daily needs. His interest in them also reflects a preference for open source and concern about providers restricting how their models can be used.

The scaffold is inspected before the project grows:

  1. Initialize Git and remove a generated CLAUDE.md that Arnaldi attributes to Bun.
  2. Create src and test directories, then move the entry file into place.
  3. Review @types/bun and compiler settings including bundler resolution, noEmit, strict, skipLibCheck, and noImplicitOverride.
  4. Run the smoke test and verify the baseline with bun run test and bun run typecheck.

Only then does he add Effect beta.

The recording uses Effect v4 beta, explicitly described as not yet released for production, and the effect-smol repository. Arnaldi explains the name as a small implementation that grew, while describing its bundle as still thin. That historical repository is now archived, with its v4 history moved to Effect-TS/effect; the examples here retain the workshop’s beta context. The test integration is @effect/vitest.

13:1313:30
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:13 · section reference included

Connect the compiler and make diagnostics blocking

The native TypeScript setup is unfamiliar to Arnaldi, so he asks the agent to read the README. The discussion separates the compiler, VS Code integration, and Effect’s language service. The Effect TypeScript-Go documentation explains its relationship to the upstream compiler and version pinning—the page visible during this part of the setup.

GitHub README showing Relationship to Official TypeScript-Go, Version Pinning, and When to Upgrade above the Plugin Options heading.Open full source frame
Effect-tsgo documentation explains its relationship to TypeScript-Go and version pinning.

Installation is not smooth. The agent reports that typescript-go is a placeholder security package and switches to the preview compiler supplying tsgo. Microsoft’s native-preview announcement identifies that package as @typescript/native-preview. The intended checking script is tsgo --noEmit; a bun exec attempt reports that tsgo is missing, after which Arnaldi tries the project’s bun run typecheck script.

Editor setup then requires the Native Preview extension, TSGo enablement, and local-service configuration. A command-line file/configuration diagnostic and a tentative diagnosis involving Bun interrupt the process. The decisive connection check is a dangling Effect expression: if the language service is working, it should complain. After checking the prepare/post-install wiring and reloading the window, diagnostics appear. Installing a package and seeing its diagnostics in the editor are separate milestones.

Feedback becomes useful back pressure when the agent cannot ignore it. Arnaldi asks for available Effect diagnostics—suggestions and warnings included—to become errors. An attendee suggests Kit Langton’s Effect Solutions, which provides setup guidance and strict defaults. Arnaldi objects to adding another CLI the model must learn; the attendee corrects one detail: the CLI exposes the guide’s documentation, rather than directly serving the repository. Its quick start separately recommends cloning Effect. The live setup continues with diagnostics set to error, an editor reload, and format on save enabled.

20:1920:30
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

20:19 · section reference included

Give fresh sessions a durable starting point

With the baseline committed, Arnaldi asks the agent to add Effect as a squashed Git subtree at .repos/effect, without importing the full upstream history. He checks git log to confirm the addition. Before researching the HTTP API, he starts a fresh OpenCode session to clear the setup conversation, then creates AGENTS.md with the available commands and directions to consult .repos/effect for implementations and best practices. The file supplies continuity when conversation context is discarded.

Instructions evolve in response to observed mistakes. Arnaldi points to his Accountability project’s custom ESLint rules: prefer schemas over assertions, prohibit undesirable uses of any and unknown, and stop the agent from asserting its way around the type system. Banning unknown alone was insufficient. After losing the as unknown as X route, the agent discovered as never as X; he then banned assertions themselves. The failure mode is not a particular keyword but bypassing the evidence a type is supposed to represent. A project linter is still only being discussed at this stage.

The generated command list exposes another trap: watch-mode tests and development servers do not terminate. In this agent workflow, running them as ordinary foreground checks can leave the session stuck. Arnaldi adds a rule against watch commands and dev servers, keeping the initial AGENTS.md concise enough to serve as a useful entry point rather than an exhaustive manual.

35:0335:27
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

35:03 · section reference included

Research once, then implement from a specification

The first feature request is deliberately about research: explore how Effect implements HTTP APIs with OpenAPI documentation and a typesafe client, save the findings to patterns/httpapi.md, and ask questions where needed. Arnaldi adopts the perspective of someone who does not know the library. This produces a reusable explanation before the agent commits to application code.

He prefers a persisted Markdown specification to the plan mode he finds restrictive in OpenCode. Implementation can then proceed in a Ralph loop: a Bash script repeatedly launches the agent, asks it to choose one small task, implement it, and exit. The next iteration starts with fresh context and reads the durable specification. This avoids relying on a human to notice when one conversation has accumulated too many unrelated jobs.

A related experiment reduces the agent’s tool surface to one execute tool capable of running TypeScript, including invoking Bash. Without a direct patch tool, the agent writes programs that modify files and sometimes uses AST transformations. Arnaldi reports promising qualitative results from this restriction. The common idea is to simplify the operating loop while preserving enough capability to finish the task. The HTTP research is now saved.

VS Code displays HTTP API Pattern Research above an OpenCode response reporting saved research and summarizing its recommendation.Open full source frame
The agent reports saving HTTP API research to a pattern file.

The research recommends a shared HTTP API definition. That contract supplies the server shape, derives OpenAPI, and supports a typed client through HttpApiClient.make. A separately generated client artifact is unnecessary for this application.

ArtifactResponsibility
Shared HttpApi definitionDescribe the API contract.
OpenAPI documentExpose that contract to external consumers.
HttpApiClient.makeBuild the typed client from the shared definition.
patterns/httpapi.mdExplain the approach and point to upstream examples.

Arnaldi checks that the research references upstream files and tests, then asks for the patterns files to be indexed in AGENTS.md.

This preparation also applies to an established codebase. Arnaldi judges an agent by whether it can maintain patterns across a large project, not merely by how impressive its first scaffold looks. In a years-old application, he would begin by letting the agent explore the code, clone the important dependencies—TanStack Router or Svelte are his examples—and derive guidance relevant to that project. Repository preparation becomes a substantial part of the programmer’s work.

41:3941:49
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

41:39 · section reference included

Test the runtime before building the todo API

Before implementation, Arnaldi checks whether Vitest is actually running under Bun. Launching a package script with Bun does not by itself settle that question: Bun’s runtime documentation explains that a CLI’s Node shebang can select Node. Meanwhile, the missing Vitest configuration allows test discovery to wander into .repos and run Effect’s own tests. The reference checkout should be visible to the agent but excluded from application test collection.

He asks for a test that requires a Bun API. The agent initially changes the assertion to make the test pass instead of repairing runtime selection. Arnaldi rejects the change: the API should be present. A compact TypeScript check expressing that requirement is:

typescript

import { expect, test } from "vitest";

test("runs with Bun APIs available", () => {
  expect(typeof Bun).toBe("object");
  expect(typeof Bun.file).toBe("function");
});

A passing test is useful only if its assertion still expresses the requirement. Arnaldi eventually accepts the corrected setup. The final invocation is not stated in the dialogue; Bun documents --bun as an override, but that should not be substituted for the unseen workshop command.

The application specification then becomes concrete:

  • Create: accept a title and description.
  • Update: change a todo’s fields.
  • Completion: mark a todo done or not done.
  • List: return the todos.

The agent is asked to discuss the plan and save it to plans/todo-api.md, using patterns/httpapi.md as generic guidance while retaining access to the original Effect source.

Storage introduces a second research task. Arnaldi chooses Effect SQL with SQLite and asks for patterns/sql.md before implementation. Generating patterns only when a capability is needed keeps adoption selective: the project need not use every part of Effect. In a brownfield application, an existing persistence choice could remain in place; Drizzle would also have been a possible choice here.

49:5450:09
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

49:54 · section reference included

Reusable patterns still need local judgment

Could library authors distribute these patterns so every project does not repeat the exploration? An attendee raises the variation in model quality visible in generated OpenClaw contributions and suggests official patterns colocated with packages. Arnaldi describes a possible CLI that would prefetch selected patterns or generate them from source, then allow project-specific revision. Reuse is attractive, but the result still has to fit the application.

Model differences complicate the idea of one universal instruction file. In Arnaldi’s experience, uppercase emphasis gets Claude’s attention but can make GPT more passive and agreeable. He therefore considers generating guidance for the model family in use. One proposal starts with curated, model-neutral patterns and transforms them; his preferred direction is self-explanatory source and examples from which a model can generate its own guidance. These remain experiments, alongside the possibility of fine-tuning an open model for Effect and an attendee’s suggestion of a v4 audit agent.

The next interaction exposes a different preference: GPT keeps asking whether to continue. Arnaldi finds Opus more proactive but more inclined to shortcuts, while he prefers GPT-5.4’s eventual output on complex tasks. An accepted shortcut can become a local convention: once as any exists, the agent may reuse it everywhere, or remove code simply to regain compilation. His extensive Accountability lint rules grew out of those experiences. Once implementation begins, the agent visibly consults Effect’s source and AI documentation—the repository reference is being used, not merely listed in an instruction file.

VS Code shows a short TypeScript file above OpenCode research activity, repository file reads, and an implementation checklist.Open full source frame
The agent consults Effect source files and AI documentation as implementation begins.
58:5559:09
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

58:55 · section reference included

Make types correspond to runtime evidence

While the implementation runs, the discussion turns to domain schemas. A handwritten interface supplied as a SQL template’s type parameter does not validate the rows the database returns. It can amount to a cast disguised as a query API. Arnaldi’s custom rule bans that pattern and recommends SqlSchema, including SqlSchema.findOne, so the correction tells the agent what to do instead.

Identifiers reveal the same problem at another boundary. If both a user ID and some unrelated ID are plain strings, TypeScript can accept one where the other is required. Branded identifiers distinguish them, but value as UserId bypasses that distinction. Arnaldi bans the assertion and points to constructors such as UserId.make where construction is appropriate.

Construction is still not a substitute for validating external input. The agent had produced API schemas with plain strings, then constructed domain values inside handlers. Arnaldi moves the requirement outward: the incoming schema should validate the identifier so the handler receives the domain value it actually needs. A constructor inside a handler can therefore be a signal that the boundary schema is too weak. The rules emerge from specific failures, then close the route by which those failures recur.

1:05:391:05:51
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:05:39 · section reference included

Switch models when needed, then review the code

Asked how he chooses between Codex and Claude, Arnaldi offers no fixed routing rule. The harness—OpenCode or his own TypeScript integration through an AI SDK—matters to him, and he attributes his move toward OpenAI to restrictions affecting his preferred Anthropic usage. That account does not establish a blanket prohibition on custom paid-API clients. He prefers Opus for UI work and has seen it solve a bug after GPT stalled, but has also seen the reverse. Trying another model when progress stops is part of the workflow.

The generated implementation has an SQL client, inline migrations, and a live SQL layer provided to the migration layers. That composition looks plausible, but some setup is duplicated. Attendees suggest Knip for detecting unused code left behind by generation or refactoring. Arnaldi describes a complementary experiment with semantic code search: agents sometimes implement an existing feature again because they fail to find it. Better discovery can prevent duplication before cleanup tools encounter it. The repeated database wiring is identified here, without a demonstrated resolution.

The migrations.ts editor shows makeDatabaseLive and DatabaseLive with similar layer composition, followed by DefaultDatabaseLive.Open full source frame
Database composition code repeats the SQL and migration layer wiring.

The API review separates correctness from future conventions. Todo identifiers remain plain strings, so branding is still an improvement to request. TodoNotFound has a schema annotation mapping it to HTTP 404. Arnaldi prefers schema classes to Schema.Struct, but accepts the generated structs; a pattern file or targeted lint rule could enforce his preference later. Despite the earlier language-service setup and format-on-save setting, this project still has no installed linter or formatter.

1:09:231:09:35
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:09:23 · section reference included

Run the API and inspect the contract

The client accepts a base URL, and the project contains live handlers and a server. The generated index.ts, however, only exports modules. Arnaldi asks for an executable entry point that starts the server only when the file is run as main, preserving safe imports. He also confirms that there is no global AGENTS.md supplying hidden project conventions.

The tests contain custom helpers such as withHttp, makeTestHttpLive, and withRepository. Arnaldi runs bun run test and observes that the tests pass. He asks for a start command and the documentation location, while noting that the test helpers could probably be replaced with it.layer. Running bun run start brings up the API; he inspects todo listing, the generated OpenAPI specification, and its schemas. This establishes a local working result, not a hosted deployment. Generated SQLite database and WAL files are then added to ignore rules.

1:15:581:16:07
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:15:58 · section reference included

Simplify test setup without losing isolation

Test cleanup begins in the same long-running session, prompting Arnaldi to notice that he is falling into the context-reuse habit he warned about. He asks for it.layer and a separate folder for utilities. An attendee suggests researching a testing pattern first; Arnaldi agrees that would have been better, but proceeds with the refactor and plans to capture the result afterward.

The unnecessary helper manually builds a layer, provides it to an Effect, and wraps execution in Effect.scoped so resources close afterward. Arnaldi suspects the agent copied a pattern used to test layer internals upstream. That is a useful warning about source-based generation: a real upstream pattern can still be wrong for the application’s level of abstraction. Here, it.layer already provides the needed test integration. If the repetition looks suspicious but its purpose is unclear, ask why it exists and what alternatives are available; sometimes the model has a valid reason.

The demonstrated organization places it.layer around a group of tests, supplies the layer, and uses it.describe inside its callback. That simplifies resource setup, but an attendee immediately raises the database question: can shared state contaminate later tests? Yes. Managed resource lifetime and database-content isolation are different concerns.

Isolation strategyMain tradeoff
Layer per testFresh resources, repeated setup cost.
Shared database layerReuses infrastructure, requires state cleanup.
Transaction per testRolls back test writes on completion.

Starting a PostgreSQL instance for every test can be expensive across a large suite; the workshop’s SQLite case is lighter. Arnaldi describes running each test inside a transaction and rolling it back afterward. For a concrete illustration, suppose the database initially contains todo 1, titled Read Effect tests. A test inserts todo 2, titled Check rollback. Rolling back removes todo 2 while preserving todo 1. This is a proposed isolation pattern, not a change demonstrated in the workshop application.

Rollback removes the test’s write

Constructed example: Todo IDs, titles, and the two-row database state are teaching values constructed to illustrate the proposed transaction rollback pattern.

Test write inside a transaction — unchanged
Insert todo 2 with title Check rollback into a database already containing todo 1 with title Read Effect tests.

Operation: Roll back the test transaction after the test finishes.

Pre-existing todo

Before: Inside the transaction, after the test insert
id: 1; title: Read Effect tests
After: After rollback · Unchanged
id: 1; title: Read Effect tests

Todo inserted by the test

Before: Inside the transaction, after the test insert
id: 2; title: Check rollback
After: After rollback · Removed
Not present
The test’s inserted row disappears while the pre-existing row remains.
1:20:511:21:07
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:20:51 · section reference included

Turn the correction into the next session’s guidance

A question about Context7 brings the knowledge path back into view: the agent has the local Effect checkout, an AGENTS.md pointing to it, and SQL and HTTP pattern files derived from source. The session now contains enough testing knowledge to create patterns/testing.md and add it to the index. The new guidance should cover @effect/vitest, it.effect, and it.layer.

The repeatable operation is small enough to automate: research a capability, create a pattern file, and update the index. OpenCode and Claude Code slash commands can package that sequence. Skills can serve the same bounded purpose across a team using different agents, including Cursor. Arnaldi distinguishes that use from adding a skill for every framework internal, which risks filling context with irrelevant material.

Reviewing the saved testing guidance, he finds the expected helpers and a specific prohibition on custom wrappers that call Layer.build. Its specificity is a feature: like an oddly precise rule posted in a pub, it exists because someone already did the thing it forbids. Here the agent did it. The document also links the relevant upstream files, preserving a route from the condensed rule back to its source.

1:27:231:27:33
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:27:23 · section reference included

Pattern files are maintained artifacts

Source links can go stale. Arnaldi mentions a friend developing a linter that checks references in CI after code changes. An attendee adds a portability concern: generated guidance sometimes embeds a developer’s absolute filesystem path. A useful pattern should point to a location other contributors can resolve, not a particular machine’s home directory.

Another proposal treats patterns like code: write a program using the pattern, compile it, and test its behavior. The testing document on screen contains both recommended guidance and an example to avoid, so executing every code block indiscriminately would be wrong. Arnaldi notes that some pattern snippets are not intended to be executable at all.

VS Code displays testing.md with guidance on reusable test layers, a preference for layers over manual construction, and an example beneath Avoid patterns like.Open full source frame
A testing pattern document records reusable test-layer guidance and an example to avoid.

Explicit markers could distinguish executable examples from explanatory fragments, and real file references from hypothetical names such as ABC. A broader evaluation would ask an agent to generate code from a pattern, then check whether the result matches expectations. That could detect regressions when the model changes as well as when the library changes. The participants see more value in this investment for curated domain-wide guidance than for every individual project.

1:31:221:31:28
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:31:22 · section reference included

Measure what the guidance produces

Arnaldi describes a proposal for daily Effect repository evaluations and reports, making changes to the library, documentation, and examples visible in generated output. Typechecking offers a concrete signal. Terseness, verbosity, and file organization are harder: two structures can both communicate meaning, and preferences still differ. The team’s evaluations therefore encode its view of good Effect code rather than an absolute definition of code quality.

The evaluation approach he describes compares generated code with human-written best-practice code and asks an LLM to score the difference. The team is still researching how to make that useful, particularly because contemplated Effect fine-tuning and reinforcement learning would require reliable evaluations. With the application and pattern files in place, Arnaldi asks the agent to commit them.

He then creates a repository, selects an owner, adds the remote, and initiates a push so attendees can access the work. The live implementation has reached a working local todo API; clustering and workflows have not been built. Those unfinished capabilities provide the final design problem.

1:34:121:34:21
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:34:12 · section reference included

The next problem is surviving interruption

Adding registration would turn a simple database application into a process spanning independent systems. A typical sequence writes a user record and sends an email, or sends a code and waits for confirmation. A database transaction does not cover the email provider. If the server crashes between those operations, the database may contain the user while the email remains unsent. Arnaldi uses the familiar instruction to retry if an email never arrives as an example of pushing recovery onto the user.

Queues are one approach; workflow systems such as Temporal and Inngest are another. Arnaldi describes Effect Workflows running on Effect Cluster across Bun or Node instances, with interrupted work moving elsewhere after a server failure. He presents eventual completion as the architectural goal, but the workshop does not implement or establish the retry and external-side-effect conditions needed for that outcome. At recording time, he describes these APIs as unstable. His next development step would repeat the same process: inspect the repository, extract Cluster and Workflow patterns, then specify and implement registration.

Long-running AI work makes interruption more consequential. Arnaldi contrasts a ten-millisecond request with a minute-long AI process: the latter stays exposed to failure for longer. His small-user-count and large-scale examples illustrate that concern rather than quantify failure probability. He connects growing interest in Temporal to AI adoption, then points to Effect’s composable workflows, clustering, AI integrations, and Discord and Slack integrations as pieces that can participate in those applications.

The local API began with an empty repository and the workshop’s assumed novice perspective on Effect. It ends with source the agent can inspect, patterns it can rediscover in a fresh session, and a working application that has already exposed the next rules worth preserving. Cloning the dependency supplied the raw material; the engineering work was turning that material into a repeatable path from research to implementation and correction.

1:38:081:38:13
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:38:08 · section reference included

Resources

From the talk

Updates since the talk

Transcript download
Full transcript

Loading transcript…