
`os.CreateTemp` and `os.MkdirTemp` create temporary files and directories with unique, non-colliding names. They are the safe replacement for manual temp-file construction, which is vulnerable to race conditions.

<ExamplePair>
<ExampleProse>

`os.CreateTemp` creates a new file in the system temp directory (or a specified dir) with a unique name built from the given pattern. The returned `*os.File` is open for reading and writing. Clean up with `os.Remove` when done.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    // "" uses os.TempDir(); the name will be something like /tmp/example-1234567890
    f, err := os.CreateTemp("", "example-")
    if err != nil {
        panic(err)
    }
    defer os.Remove(f.Name()) // clean up on exit
    defer f.Close()

    fmt.Println("temp file:", f.Name())

    _, err = f.WriteString("temporary content\n")
    if err != nil {
        panic(err)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`os.MkdirTemp` creates a temporary directory. Use it when you need a temporary workspace for multiple files. Clean up the whole tree with `os.RemoveAll` when done.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
    "path/filepath"
)

func main() {
    dir, err := os.MkdirTemp("", "workspace-")
    if err != nil {
        panic(err)
    }
    defer os.RemoveAll(dir) // clean up entire directory

    fmt.Println("temp dir:", dir)

    // Create files inside the temp directory
    p := filepath.Join(dir, "data.txt")
    err = os.WriteFile(p, []byte("hello"), 0600)
    if err != nil {
        panic(err)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

In tests, use `t.TempDir()` instead of `os.MkdirTemp`. It returns a unique directory that the test runner removes automatically when the test completes - no manual cleanup needed.

</ExampleProse>
<ExampleCode>

```go
package mypackage_test

import (
    "os"
    "path/filepath"
    "testing"
)

func TestWriteConfig(t *testing.T) {
    dir := t.TempDir() // cleaned up automatically after the test

    cfg := filepath.Join(dir, "config.json")
    err := os.WriteFile(cfg, []byte(`{"debug":true}`), 0600)
    if err != nil {
        t.Fatal(err)
    }

    // test logic that reads from cfg...
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Always clean up temp files and directories, preferably with `defer` immediately after creation - a crash or early return without the defer running leaves them on disk. Temp files created by `os.CreateTemp` are not deleted on process exit. In tests, `t.TempDir()` is always preferable to manual `os.MkdirTemp` + `defer os.RemoveAll` - the test runner handles cleanup even if the test panics. When writing to a temp file and then renaming it over a real file (atomic write pattern), create the temp file in the same directory as the target so the rename stays on the same filesystem - cross-device renames fail with `EXDEV`. Set restrictive permissions (`0600` for files, `0700` for directories) on temp paths that contain sensitive data; `os.TempDir()` is world-readable on Linux by default.
</InProduction>


os.CreateTemp and os.MkdirTemp for creating temporary files and directories, deferred cleanup, and t.TempDir in tests.

Temporary Files and Directories


The `//go:embed` directive lets you bundle static files and directories into the compiled binary at build time. The `embed` package provides the `embed.FS` type for accessing embedded content at runtime.

<ExamplePair>
<ExampleProse>

Import the `embed` package and place a `//go:embed` comment immediately before a variable of type `string`, `[]byte`, or `embed.FS`. The compiler reads the file at build time and bakes it into the binary.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    _ "embed"
    "fmt"
)

//go:embed hello.txt
var content string

func main() {
    fmt.Print(content)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`embed.FS` can hold multiple files or entire directory trees. Use `fs.ReadFile` or the methods on `embed.FS` to read them. The embedded paths must be relative and cannot use `..`.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "embed"
    "fmt"
)

//go:embed templates
var templateFS embed.FS

func main() {
    data, err := templateFS.ReadFile("templates/index.html")
    if err != nil {
        panic(err)
    }
    fmt.Printf("template size: %d bytes\n", len(data))

    entries, _ := templateFS.ReadDir("templates")
    for _, e := range entries {
        fmt.Println(e.Name())
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Pass an `embed.FS` to `http.FileServer` via `http.FS` to serve embedded static assets. The server reads from the in-memory filesystem, not the disk.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "embed"
    "net/http"
)

//go:embed static
var staticFiles embed.FS

func main() {
    http.Handle("/", http.FileServer(http.FS(staticFiles)))
    http.ListenAndServe(":8080", nil)
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
`go:embed` is the idiomatic way to ship static assets (HTML templates, database migrations, default config files) inside a single binary. The embedded content is read-only at runtime - you cannot write back to it. For large assets, weigh the binary size increase against the deployment simplicity gain; embedding gigabytes of media is a valid use case for dedicated object storage instead. `embed.FS` implements `fs.FS`, so any function that accepts `fs.FS` (including `html/template.ParseFS` and `text/template.ParseFS`) works directly with it. In tests, use `//go:embed testdata` in test files to embed fixtures alongside the test - the testdata directory is the convention for this.
</InProduction>


The //go:embed directive bundles static files and directories into the compiled binary using embed.FS, enabling single-binary deployments.

Embed Directive


The `os` package provides functions for creating, listing, and removing directories. Most operations mirror the familiar Unix commands but are portable across operating systems.

<ExamplePair>
<ExampleProse>

`os.Mkdir` creates a single directory. It fails if the path already exists or if any intermediate directory is missing. `os.MkdirAll` creates the full path including all intermediate directories, and is idempotent - it returns `nil` if the directory already exists.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    // Create a single directory - fails if parent doesn't exist
    err := os.Mkdir("subdir", 0755)
    if err != nil {
        panic(err)
    }

    // Create a full path - idempotent, no error if already exists
    err = os.MkdirAll("a/b/c", 0755)
    if err != nil {
        panic(err)
    }

    fmt.Println("directories created")
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`os.ReadDir` lists the entries in a directory, sorted by name. Each `fs.DirEntry` provides the name, type (file or directory), and - via `Info()` - the full `fs.FileInfo`.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    entries, err := os.ReadDir(".")
    if err != nil {
        panic(err)
    }

    for _, e := range entries {
        kind := "file"
        if e.IsDir() {
            kind = "dir "
        }
        fmt.Printf("%s %s\n", kind, e.Name())
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`os.Remove` deletes a single file or empty directory. `os.RemoveAll` deletes a path and everything under it - equivalent to `rm -rf`. `os.Getwd` returns the current working directory; `os.Chdir` changes it.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    os.MkdirAll("tmp/nested", 0755)

    // Remove a single empty directory
    os.Remove("tmp/nested")

    // Remove a directory tree (rm -rf equivalent)
    os.RemoveAll("tmp")

    wd, err := os.Getwd()
    if err != nil {
        panic(err)
    }
    fmt.Println("working dir:", wd)
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
`os.RemoveAll` is equivalent to `rm -rf` - no confirmation, no recycle bin, no undo. In production code, validate that the path is inside a known prefix (using `filepath.Abs` and `strings.HasPrefix`) before calling it; a bug that constructs a wrong path can delete critical data. `os.MkdirAll` is idempotent - prefer it over a stat-then-mkdir sequence, which has a TOCTOU race. `os.ReadDir` is the modern replacement for `ioutil.ReadDir` (deprecated) and is faster because it uses the `fs.DirEntry` type that avoids a `stat` call per entry when only the name and type are needed. For recursive traversal, use `filepath.WalkDir` rather than calling `os.ReadDir` recursively - it handles errors consistently and lets you skip subtrees by returning `fs.SkipDir`. Avoid `os.Chdir` in server code - it changes the working directory for the whole process, not just the current goroutine.
</InProduction>


os.Mkdir, os.MkdirAll, os.ReadDir, os.Remove, os.RemoveAll, os.Getwd, and os.Chdir for directory operations.