# Effect basics

> For agents: start with the [agent guide](https://ratstack.sh/llms.txt). Every page is Markdown by default; add `Accept: text/html` for HTML.

New on /news: [Effect Office Hours 52 with Resonate HQ](/news).

A service is a named interface for work. A context holds supplied service implementations.

An Effect describes work. Build the description, compose it with other Effects, supply its services, then let a runtime execute it.

## Read the three type parameters

`Effect.Effect<A, E, R>` describes three things:

- **`A`**:
  - Meaning: Success value
  - FileInspector's inspect method: `FileStats`
- **`E`**:
  - Meaning: Expected failure
  - FileInspector's inspect method: `FileStatsError`
- **`R`**:
  - Meaning: Required services
  - FileInspector's inspect method: `never`

This method's full return type is `Effect.Effect<FileStats, FileStatsError, never>`.
The source omits the final parameter because it defaults to `never`.

packages/core/src/file-inspector.ts at 65e9465f38092e24486392f22c08f45d61230c20; lines 6-15; highlighted none.

```typescript
export class FileInspector extends Context.Service<
  FileInspector,
  {
    readonly inspect: (
      path: string
    ) => Effect.Effect<FileStats, FileStatsError>;
  }
>()("@rat-stack/core/FileInspector", {
  make: Effect.gen(function* makeFileInspector() {
    const fileSystem = yield* FileSystem.FileSystem;
```

Constructing the inspector needs `FileSystem`. Its returned method has captured that dependency and does not require it again.

`R = never` means no services remain to supply. It does not mean the computation cannot fail.
`E = never` means no declared expected failures; it does not rule out defects or interruption.

## A description is not a completed operation

Calling `inspector.inspect(path)` produces an Effect description. It does not read the file immediately.
The method composes the read with an error translation before a runtime executes either operation.

packages/core/src/file-inspector.ts at 65e9465f38092e24486392f22c08f45d61230c20; lines 17-29; highlighted none.

```typescript
    const inspect = Effect.fn("FileInspector.inspect")(function* inspect(
      path: string
    ) {
      const content = yield* fileSystem
        .readFile(path)
        .pipe(
          Effect.mapError(
            (error) => new FileStatsError({ path, reason: error.message })
          )
        );

      return summarizeBytes(path, content);
    });
```

Ordinary JavaScript still evaluates while you build a description.
Starting a Promise first, then wrapping it, does not undo that eager work.
Keep external work inside the Effect constructor's callback.

## Write a sequence with gen; transform it with pipe

`Effect.gen` composes Effects in generator syntax. `yield*` obtains a success value or propagates the failure.
The generator describes work for the Effect runtime.

Use `pipe` for short transforms, such as mapping a value, translating a failure, or providing a service.
Use a generator when the next step needs values from earlier steps.

- Combinators are functions that combine or transform Effects.

Generators and combinators both compose descriptions without running a nested runtime.

- In rat-stack, prefer `Effect.gen` for inline sequences. Use `Effect.fn` for reusable functions with useful tracing names.
- Do not write long combinator chains merely to avoid a clear generator.

## Expected failures and defects are different

An [expected failure](/lore/error-model) belongs in `E`, where callers can handle it by its declared type or tag.
A defect is an unexpected execution failure.
Logging a failure does not make the operation successful.
[Handle expected failures without hiding defects](/lore/error-model) shows the file error and its CLI handler.

## Requirements name services to supply

A requirement is a service the computation needs.
A Layer describes how to build a service and supply its dependencies.

Layers build implementations and satisfy their construction dependencies.
Getting `FileInspector` from context requires that service; calling its captured `inspect` method needs no extra service.
Read [service construction](/lore/services-capture-dependencies), [Layer composition](/lore/layers-make-dependencies-explicit), and [context and requirements](/lore/context-and-requirements).

## Run at the application boundary

The CLI builds and transforms a program with `pipe`, then provides its services and their dependencies.
`NodeRuntime.runMain` executes the final Effect:

apps/cli/src/cli.ts at b4d6b8f499e57bc76914ad70df3a0c99751ae28c; lines 22-35; highlighted none.

```typescript
  Effect.provide(
    Layer.mergeAll(
      Layer.provideMerge(FileInspector.layer, NodeServices.layer),
      remoteJoinInterestLayer,
      localPromptLibraryLayer.pipe(Layer.provide(NodeServices.layer)),
      localCafeDirectoryLayer.pipe(Layer.provide(NodeServices.layer)),
      localLearnLayer,
      Flags.defaults(eventFlags),
      Approval.denyAll
    )
  )
);

NodeRuntime.runMain(program);
```

The Worker returns a fetch Effect to its Alchemy Worker adapter:

apps/site/src/worker.ts at b4d6b8f499e57bc76914ad70df3a0c99751ae28c; lines 337-342,357-365; highlighted none.

```typescript
    return {
      fetch: observeRequestLog(
        observeRequestIncidents(
          events === undefined
            ? readerApp
            : Effect.gen(function* captureWithLiveIdentity() {
                return yield* withEventCapture({
                  captureCity: true,
                  identityMode: currentIdentity,
                  runInBackground: inBackground,
                })(readerApp).pipe(Effect.provideContext(events));
              })
        )
      ),
    };
```

The Worker adapter owns request execution. The domain does not scatter `runPromise` calls through handlers.

In tests, `it.effect` owns execution of the returned Effect. The test still supplies the services it needs.
See [tests through supplied services](/lore/tests-that-earn-their-place).
[Run Effect at the integration boundary](/lore/run-effect-at-the-boundary) covers foreign code, runtime reuse, and disposal.

## The common wrong first version

Scattering `await Effect.runPromise(...)` through library methods creates separate execution boundaries where composition should remain intact.
It also turns the expected failure into a rejected Promise rather than preserving the Effect error channel for the caller.
Return the composed Effect and let the application boundary run it.

`Effect.promise` assumes Promise rejection is an unexpected defect.
For an external API with expected failures, use `Effect.tryPromise` with a translation into a named domain error.
Wrapping an already-started Promise also loses control over when its work begins.

## Read next

1. [Effect basics](/lore/effect-basics): build a description before running it.
2. [Schemas define the boundary](/lore/schemas-define-the-boundary): define and decode accepted data.
3. [Expected failures and defects](/lore/error-model): name failures without hiding crashes.
4. [Service construction](/lore/services-capture-dependencies): capture implementation dependencies.
5. [Layer composition](/lore/layers-make-dependencies-explicit): supply the graph at an entrypoint.
6. [Configuration](/lore/configuration-is-a-dependency): parse supplied settings.
7. [Testing](/lore/tests-that-earn-their-place): prove behavior through supplied services.
8. [Scopes](/lore/scopes-own-resources): acquire resources inside their owner and release them on exit.
9. [Concurrency](/lore/concurrent-work-needs-an-owner): bound work and stop owned children.
10. [HTTP responses](/lore/http-responses-need-validation): check status and decode accepted data.
11. [Tracing](/lore/trace-meaningful-operations): name meaningful operations and inspect export evidence.
12. [Runtime boundaries](/lore/run-effect-at-the-boundary): execute through the framework's Effect integration and connect disposal.

## Sources

1. [Arnaldi, Michael. n.d. TypeScript & Effects with Michael Arnaldi. Happy Path 81.](https://youtu.be/gc5P36t6kD0?t=2955)
   Michael Arnaldi. Historical explanation at 49:15 of success, errors, and requirements; current API evidence comes from the pinned source. Accessed 2026-10-06.

2. [Arnaldi, Michael. n.d. Why JavaScript Is Broken: How Effect and TypeScript Fixes It.](https://youtu.be/und9h4xiIz4?t=752)
   Michael Arnaldi. Historical explanation at 12:32 of lazy computations that can be transformed before execution. Accessed 2026-10-06.

3. [Effect contributors. 2026. Effect. Effect 4.0.0.](https://github.com/Effect-TS/effect/blob/67ba4e46a11ccda0b6761578bfd22c04ae00167d/packages/effect/src/Effect.ts)
   Effect-TS. Effect\<A, E, R>, lazy execution, gen, mapError, fn, and typed failure handling. Accessed 2026-10-06.

4. [Effect contributors. 2026. Context. Effect 4.0.0.](https://github.com/Effect-TS/effect/blob/67ba4e46a11ccda0b6761578bfd22c04ae00167d/packages/effect/src/Context.ts)
   Effect-TS. Service keys express requirements; supplied context satisfies them. Accessed 2026-10-06.

5. [Effect contributors. 2026. Effect Vitest integration.](https://github.com/Effect-TS/effect/blob/67ba4e46a11ccda0b6761578bfd22c04ae00167d/packages/vitest/src/index.ts)
   Effect-TS. it.effect owns execution of an Effect returned by a test. Accessed 2026-10-06.

6. [rat-stack contributors. 2026. rat-stack source snapshot.](https://github.com/joelhooks/rat-stack/tree/65e9465f38092e24486392f22c08f45d61230c20)
   rat-stack. FileInspector's method type, CLI composition and execution, Worker fetch Effect, and Effect-aware tests. Accessed 2026-10-06.

## Lore on this page

- [Workers answer requests; Durable Objects own named state](/lore/workers-answer-requests-durable-objects-own-named-state)
- [Failures keep their meaning](/lore/failures-keep-their-meaning)

## Linked from

- A cartridge owns one job and its resources → A cartridge owns one job and brings the infrastructure its service needs. → [Read page](https://ratstack.sh/lore/cartridges)

- A Layer as constructor → Sam Goodwin compares an Effect Layer that builds a service to a constructor. → [Read page](https://ratstack.sh/lore/layer-constructor-pattern)

- Accumulate independent errors before writing output → Check every independent job before any job writes an asset. → [Read page](https://ratstack.sh/lore/accumulate-independent-errors)

- Agent guide → An Effect stack so pure (aspirational) Kit Langton will blush. → [Read page](https://ratstack.sh/llms.txt)

- Alchemy Domain models a business as commands, aggregates, and events → Alchemy Domain is a domain-driven design framework for Effect whose one model runs in memory for tests and on Cloudflare Durable Objects in production. → [Read page](https://ratstack.sh/lore/alchemy-domain)

- Bindings → Sam Goodwin describes bindings as the place where runtime permissions and configuration meet infrastructure. → [Read page](https://ratstack.sh/lore/bindings)

- CAFE all stars → Public profiles of people and channels who build with Cloudflare, Alchemy, Foldkit and Effect, served by five read-only capabilities. → [Read page](https://ratstack.sh/systems/all-stars)

- Change log → What changed in the files served here, newest first. → [Read page](https://ratstack.sh/log)

- Cleanup can be an idempotent postcondition → Already-absent state can be success when absence is the operation’s intended result. → [Read page](https://ratstack.sh/lore/cleanup-can-be-an-idempotent-postcondition)

- Concurrent work needs an owner and a bound → Limit active work, retain result order, and stop child work when its owning lifetime ends. → [Read page](https://ratstack.sh/lore/concurrent-work-needs-an-owner)

- Context and requirements → Effect requirements make a computation's needed services visible in its type. → [Read page](https://ratstack.sh/lore/context-and-requirements)

- durability → Keep a rat-stack app standing when a provider, pool, or dependency slows down or a worker dies. Use at any I/O boundary, connection pool, provider call, shared waiter, fan-out, flag, gate, or work that can outlive a request, or when asked "what happens when this is slow", "add a timeout", "make this durable", or "what survives a crash". → [Read page](https://ratstack.sh/skills/durability)

- Durability → Seven durable Effect patterns, each with its seam, its fence, and the incident that taught it. → [Read page](https://ratstack.sh/systems/durability)

- Durability bibliography → Books, checked short quotations, source limits, and Effect mapping provenance. → [Read page](https://ratstack.sh/lore/durability-bibliography)

- Effect is not BEAM → Fibers share a runtime; scope ownership does not supply isolated heaps or OTP restart strategies. → [Read page](https://ratstack.sh/lore/effect-is-not-beam)

- Effect keeps the surfaces on one contract → Schema owns values, projections build interfaces, and Layers supply implementations. → [Read page](https://ratstack.sh/lore/how-we-do-it-with-effect)

- Failures keep their meaning → Expected refusals, infrastructure faults, and defects need different policies. → [Read page](https://ratstack.sh/lore/failures-keep-their-meaning)

- Feature flags → Typed feature flags with owners, removal dates, and stable subject rollouts. → [Read page](https://ratstack.sh/systems/flags)

- Full agent guide → An Effect stack so pure (aspirational) Kit Langton will blush. → [Read page](https://ratstack.sh/llms-full.txt)

- Handle expected failures without hiding defects → Declare expected failures, preserve their context, and recover by tag without turning crashes into successful outcomes. → [Read page](https://ratstack.sh/lore/error-model)

- HTTP success needs a status check and a decoder → Supply the client, check the response status, decode accepted data, and name failures at the adapter boundary. → [Read page](https://ratstack.sh/lore/http-responses-need-validation)

- Implicit state machines → Every app runs state machines; the risky ones are scattered across flags, conditions and loops where nobody can list the transitions. → [Read page](https://ratstack.sh/lore/implicit-state-machines)

- learn-rat-stack → Trace a capability through Effect, XState, five projections, the CLI, and Alchemy. Try hosted search and read. → [Read page](https://ratstack.sh/skills/learn-rat-stack)

- onboard-a-list → Analyze or migrate an email list. Measure sanitation rules, preserve stops, choose a cohort, and verify an authorized import or sending cutover. → [Read page](https://ratstack.sh/skills/onboard-a-list)

- One capability, every surface → A schema-typed contract and one handler feed every interface rat-stack keeps. → [Read page](https://ratstack.sh/lore/one-capability-every-surface)

- Pure cores reduce timeline coupling → Move deterministic rules out of time-dependent actions and shared mutable state. → [Read page](https://ratstack.sh/lore/pure-cores-reduce-timelines)

- Queues, Pipelines, Workflows and K2 do different jobs → Pick a Cloudflare product for work outside a request by the unit you track: a message, a row, a step, or a record in a log. → [Read page](https://ratstack.sh/lore/queues-pipelines-workflows-and-k2-do-different-jobs)

- Rat Stack lore | rat-stack → Short, source-grounded notes on the ideas and decisions behind rat-stack. → [Read page](https://ratstack.sh/lore)

- Recovery needs model tests → Test sequences of failures and recoveries against explicit invariants. → [Read page](https://ratstack.sh/lore/recovery-needs-model-tests)

- Replay needs stable inputs → Historical processing must not silently depend on today’s clock or external decisions. → [Read page](https://ratstack.sh/lore/replay-needs-stable-inputs)

- Retry needs idempotent effects → Repeating an operation must preserve its intended observable result. → [Read page](https://ratstack.sh/lore/retry-needs-idempotency)

- Run Effect at the integration boundary → Build the runtime where a calling framework enters, reuse its services, and dispose it when that integration ends. → [Read page](https://ratstack.sh/lore/run-effect-at-the-boundary)

- Scopes release resources when work ends → Acquire resources lazily, keep their use inside the owner, and release them after success, failure, or interruption. → [Read page](https://ratstack.sh/lore/scopes-own-resources)

- Source change history (log.md) → The generated change log as Markdown. → [Read page](https://ratstack.sh/log.md)

- Structure an Effect codebase by domain → Start with folders for application work, services and Layers in the same file, and startup code that supplies implementations. → [Read page](https://ratstack.sh/lore/structure-effect-by-domain)

- The war stories → Seven public repo incidents: a deploy undoes itself, failure says 200, sessions forget their guests, and the rat tests the demolition instructions. → [Read page](https://ratstack.sh/lore/shitrat-war-stories)

- Trace operations where they mean something → Name useful operations, add safe context, and distinguish creating a span from delivering it to a backend. → [Read page](https://ratstack.sh/lore/trace-meaningful-operations)

## Unlinked mentions

- [A cartridge owns one job and its resources](https://ratstack.sh/lore/cartridges) → Its recorded Effect yields an empty list.¶

- [A Layer as constructor](https://ratstack.sh/lore/layer-constructor-pattern) → A constructor argument becomes a Layer requirement.

- [A service captures its construction dependencies](https://ratstack.sh/lore/services-capture-dependencies) → make describes service construction as an Effect.

- [add-a-capability](https://ratstack.sh/skills/add-a-capability) → Effect describes work with typed failures and required dependencies.

- [add-a-lifecycle-machine](https://ratstack.sh/skills/add-a-lifecycle-machine) → Effect describes work with typed failures and required dependencies.

- [add-a-store](https://ratstack.sh/skills/add-a-store) → Effect describes work with typed failures and required dependencies.

- [Agent rules for rat-stack (AGENTS.md)](https://ratstack.sh/AGENTS.md) → Effect 4.1.2 and @effect/platform-node 4.1.2.

- [Agents explore, tests remember](https://ratstack.sh/lore/agents-explore-tests-remember) → The resulting checks use Effect tests.¶

- [Analytics](https://ratstack.sh/systems/analytics) → Effect is the library that describes work with typed failures and required services.

- [Build and run rat-stack (README.md)](https://ratstack.sh/README.md) → Build an Effect app and its cloud as one typed program.

- [CAFE all stars](https://ratstack.sh/systems/all-stars) → Public work builds on or teaches Cloudflare, Alchemy, Foldkit or Effect.¶

- [CAFE names the Cloudflare, Alchemy, Foldkit and Effect stack](https://ratstack.sh/lore/cafe-stack) → Job: Draws the UI with the Elm Architecture on Effect.¶

- [Capabilities](https://ratstack.sh/systems/capabilities) → Effect is a library for describing work with typed failures and required services.

- [CascadiaJS 2026: It's time to rethink everything](https://ratstack.sh/lore/cascadiajs-2026-its-time-to-rethink-everything-theo-browne) → Theo compares the cloud’s effect on infrastructure with agents’ effect on software production.

- [Code snippets quote a pinned source](https://ratstack.sh/lore/code-snippets) → Effect 4 exposes Arbitrary.schema through effect/Arbitrary.

- [Concurrent work needs an owner and a bound](https://ratstack.sh/lore/concurrent-work-needs-an-owner) → forEach describes one Effect per input and collects results in input order.

- [Configuration is a supplied, validated dependency](https://ratstack.sh/lore/configuration-is-a-dependency) → Effect’s Config.schema can describe more complex validated settings.

- [Context and requirements](https://ratstack.sh/lore/context-and-requirements) → use returns an Effect whose requirements include FileInspector.

- [Database](https://ratstack.sh/systems/database) → Effect describes work with typed failures and required services.

- [Dependency injection is the reason to choose Effect](https://ratstack.sh/lore/dependency-injection-is-the-reason-to-choose-effect) → Dillon Mulroy compares Effect with Spring and NestJS:¶

- [Dependency vendoring rules (vendor/README.md)](https://ratstack.sh/vendor/README.md) → allowedVersions entries for Foldkit’s exact Effect 4.0.0 peers travelled with it.

- [Devtools](https://ratstack.sh/systems/devtools) → Effect describes work with typed failures and required services.

- [durability](https://ratstack.sh/skills/durability) → Effect is not BEAM.

- [Durability](https://ratstack.sh/systems/durability) → Effect stays at the pinned version.

- [Durability bibliography](https://ratstack.sh/lore/durability-bibliography) → Effect contributors.

- [Durability starts with a recovery record](https://ratstack.sh/lore/durability) → Effect is not BEAM.

- [Effect + Alchemy peer patterns](https://ratstack.sh/resources/same-version-repos) → At that study date, only alchemy-run/alchemy at 9802260db8f8b5a083c4b85eb7ea31ae1ff8f176 matched both Effect and Alchemy lines: its package is beta.79 and its workspace requires Effect rc.117.

- [Effect + Alchemy peers](https://ratstack.sh/resources/peers) → Effect: 4.1.2

- [Effect 4 study: September 2026](https://ratstack.sh/resources/effect-4-reference-projects) → Effect: 4.0.0-rc.115 (catalog)

- [Effect Days 2025: Building Effect 4](https://ratstack.sh/lore/effect-days-2025-building-effect-4-michael-arnaldi) → Michael describes Effect 4 as a review of choices made in Effect 3, driven by production feedback.

- [Effect keeps the surfaces on one contract](https://ratstack.sh/lore/how-we-do-it-with-effect) → Effect Schema owns inputs, outputs, and failures in our shared contract.

- [Effect Meetup SF 2023: Why Effect?](https://ratstack.sh/lore/effect-meetup-sf-2023-why-effect-michael-arnaldi) → A Remix demo contrasts manually added logs, metrics, and traces and nested error handling with Effect context, Schema, spans, metrics, and retry policies.

- [Effect's design lineage](https://ratstack.sh/lore/effect-design-lineage) → John De Goes describes Effect as adapting ZIO’s goals to TypeScript through iterations rather than copying it directly.

- [Fence](https://ratstack.sh/systems/fence) → Effect describes work with typed failures and required services.

- [find-peers](https://ratstack.sh/skills/find-peers) → Effect describes work with typed failures and required dependencies.

- [gardener](https://ratstack.sh/skills/gardener) → Effect describes work with typed failures and required dependencies.

- [Handle expected failures without hiding defects](https://ratstack.sh/lore/error-model) → A defect is an unexpected execution failure.¶

- [Happy Path 116: Infrastructure as effects](https://ratstack.sh/lore/happy-path-116-infrastructure-as-effects-sam-goodwin) → Effect gives Alchemy a pure program: it describes work before execution and can be planned first.

- [Happy Path 81: TypeScript and effects](https://ratstack.sh/lore/happy-path-81-typescript-and-effects-michael-arnaldi) → He describes an Effect by its output, predictable failures, and requirements.

- [Hexagonal architecture](https://ratstack.sh/lore/hexagonal-architecture) → On the driven side, Effect Context.Service definitions provide ports for subscriber intake (SubscriberIntake) and confirmation (SubscriberConfirm).

- [HTTP success needs a status check and a decoder](https://ratstack.sh/lore/http-responses-need-validation) → Effect also has native schedules and retry operators.¶

- [Infrastructure as effects](https://ratstack.sh/lore/infrastructure-as-effects) → A client operation can imply a policy requirement supplied when the function is built.

- [investigate-a-failure](https://ratstack.sh/skills/investigate-a-failure) → Output that looks corrupted may be a side effect of a crash.¶

- [keep-or-cut](https://ratstack.sh/skills/keep-or-cut) → Effect describes work with typed failures and required dependencies.¶

- [Learn mode presents concepts at useful depths](https://ratstack.sh/systems/learn) → Effect describes the work with typed failures and required services.

- [learn-alchemy](https://ratstack.sh/skills/learn-alchemy) → limit({ key }) method and turns a failed runtime call into a defect instead of failing open.¶

- [learn-rat-stack](https://ratstack.sh/skills/learn-rat-stack) → Effect describes work with typed failures and required dependencies.¶

- [Lifecycles are machines](https://ratstack.sh/lore/lifecycles-are-machines) → A side effect is work outside the state description, such as reading a file.

- [Lint and type escape ledger (debt.md)](https://ratstack.sh/debt.md) → Reason: HttpRouter declares asHttpEffect’s error as unknown upstream; the MCP transport answers every request itself, so a failure here is a defect.

- [mdsvex left unified](https://ratstack.sh/lore/mdsvex-left-unified) → The fence does not permit rewriting valid prose around a parser defect.¶

- [Michael Arnaldi](https://ratstack.sh/lore/michael-arnaldi) → He describes Effect computations through their outputs, predictable failures, and requirements: the services the work needs.

- [Model-based testing](https://ratstack.sh/lore/model-based-testing) → Effect 4’s Arbitrary.array generates command sequences.

- [One schema, three surfaces](https://ratstack.sh/lore/one-schema-three-surfaces) → Effect Schema supplies types and runtime checks for these values.¶

- [OpenAPI describes the refusal too](https://ratstack.sh/lore/openapi-describes-the-refusal-too) → Effect’s OpenApi.fromApi derives the document from that HttpApi.¶

- [Oxlint rule limits](https://ratstack.sh/resources/lint-rule-limits) → Residual limit and why: Arbitrary helper functions, complex control flow, and Effect values whose resource ownership is hidden behind other abstractions need semantic analysis.

- [profile-a-worker](https://ratstack.sh/skills/profile-a-worker) → One change and its measured effect, or the reason no change is worth it.¶

- [Property-based testing](https://ratstack.sh/lore/property-based-testing) → Effect 4 ships its own engine in effect/Arbitrary.

- [Purpose and boundaries of rat-stack (VISION.md)](https://ratstack.sh/VISION.md) → Effect owns the hard parts, Alchemy infers the infrastructure from the code, and the fence raises the floor, so an agent can build it reliably with high-trust.

- [rat-stack](https://ratstack.sh/) → An Effect stack so pure (aspirational) Kit Langton will blush.

- [Retry needs idempotent effects](https://ratstack.sh/lore/retry-needs-idempotency) → Receiver-side keys or transactional dedupe must enforce the repeated effect’s semantics.¶

- [Run Effect at the integration boundary](https://ratstack.sh/lore/run-effect-at-the-boundary) → Effect-native HTTP router: Adapt its Layer with HttpRouter.toWebHandler¶

- [Schema projections: 2026-09-18 history](https://ratstack.sh/resources/schema-projections-and-code-mode) → This study records the proposal and implementation on 2026-09-18 against Effect rc.115.

- [Scopes release resources when work ends](https://ratstack.sh/lore/scopes-own-resources) → The migration adapter makes shutdown failure a defect with orDie.

- [security-audit](https://ratstack.sh/skills/security-audit) → Do not test availability against a live or shared process, publish artifacts, alter releases, spend paid API quota, or continue beyond the minimum local effect needed to establish a defect.

- [ship](https://ratstack.sh/skills/ship) → Effect: the library for describing work with typed failures and required services.¶

- [Structure an Effect codebase by domain](https://ratstack.sh/lore/structure-effect-by-domain) → runMain runs the final Effect.

- [test-behaviour](https://ratstack.sh/skills/test-behaviour) → prop when the check returns an Effect.¶

- [Tests prove behavior through supplied services](https://ratstack.sh/lore/tests-that-earn-their-place) → effect runs the Effect returned by the test.

- [The fence](https://ratstack.sh/lore/the-fence) → Effect language-service diagnostics run through TypeScript.

- [Trace operations where they mean something](https://ratstack.sh/lore/trace-meaningful-operations) → Use annotateSpans when supplying annotations through an enclosing Effect.

- [UI behaviour is a scene](https://ratstack.sh/lore/ui-behaviour-is-a-scene) → A Command is a named side effect.

- [uncomplect](https://ratstack.sh/skills/uncomplect) → Effect: The library for describing work with typed failures and required services.¶

- [Vibe engineering Effect apps](https://ratstack.sh/lore/ai-engineer-vibe-engineering-effect-apps-michael-arnaldi) → Effect is a TypeScript library for describing work with typed results, failures, and required services.¶

- [Worker init runs twice](https://ratstack.sh/lore/init-runs-twice) → A Cloudflare Worker’s initialization effect runs twice.