
The `os` package provides file writing at different granularities. `os.WriteFile` handles small writes in one call; `bufio.Writer` wraps a file for efficient large or streaming output.

<ExamplePair>
<ExampleProse>

`os.WriteFile` writes a `[]byte` to a file in one call, creating or truncating the file as needed. Suitable for config files, small generated outputs, or test fixtures where the entire content is known upfront.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    data := []byte("hello, file\nline two\n")
    err := os.WriteFile("output.txt", data, 0644)
    if err != nil {
        panic(err)
    }
    fmt.Println("wrote", len(data), "bytes")
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

For large or streaming writes, create the file with `os.Create` and wrap it in a `bufio.Writer`. The writer batches small writes into larger OS calls, reducing system call overhead. Always call `Flush()` before closing.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    f, err := os.Create("output.txt")
    if err != nil {
        panic(err)
    }
    defer f.Close()

    w := bufio.NewWriter(f)
    for i := range 5 {
        fmt.Fprintf(w, "line %d\n", i+1)
    }
    if err := w.Flush(); err != nil {
        panic(err)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`os.OpenFile` gives full control over open flags. `O_APPEND` adds to an existing file instead of truncating it, `O_CREATE` creates the file if it does not exist, and `O_WRONLY` opens for writing only.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    f, err := os.OpenFile("log.txt",
        os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        panic(err)
    }
    defer f.Close()

    _, err = fmt.Fprintln(f, "appended line")
    if err != nil {
        panic(err)
    }
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
`bufio.Writer` buffers writes in memory - call `Flush()` before closing or the last buffer is silently dropped. For durable writes (config files, ledger entries), call `f.Sync()` before `f.Close()` to flush the OS page cache to disk; `defer f.Close()` alone does not guarantee durability. The safest pattern for critical writes is to write to a temp file, call `f.Sync()`, close it, then rename atomically with `os.Rename` - readers either see the old file or the complete new file, never a partial write. `os.OpenFile` with `O_APPEND` is not atomic for writes larger than the OS write size on some filesystems; for append-only logs under concurrent writers, use a dedicated logging library or serialize writes through a goroutine.
</InProduction>


os.WriteFile for small writes, os.Create with bufio.Writer for large or streaming writes, os.OpenFile with flags, and fsync for durability.

Writing Files


A line filter reads lines from standard input, transforms them, and writes results to standard output. This is the Unix filter pattern - Go binaries that follow it compose naturally with `grep`, `awk`, `sed`, and other shell tools.

<ExamplePair>
<ExampleProse>

A minimal line filter: read every line from `os.Stdin` with `bufio.Scanner` and write it to `os.Stdout` unchanged. This is the identity filter - the template you extend to add transformations.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        fmt.Println(scanner.Text())
    }
    if err := scanner.Err(); err != nil {
        fmt.Fprintln(os.Stderr, "error:", err)
        os.Exit(1)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Add a transformation to produce a useful filter. This example uppercases every line - a trivial but illustrative change. Replace the `strings.ToUpper` call with any line-level logic you need.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        fmt.Println(strings.ToUpper(scanner.Text()))
    }
    if err := scanner.Err(); err != nil {
        fmt.Fprintln(os.Stderr, "error:", err)
        os.Exit(1)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Filters can also read from a file argument and fall back to `os.Stdin` when none is provided - the convention followed by most Unix tools. `os.Stdin` implements `io.Reader`, so `bufio.NewScanner` accepts it directly.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
    "strings"
)

func filter(r io.Reader) {
    scanner := bufio.NewScanner(r)
    for scanner.Scan() {
        fmt.Println(strings.ToUpper(scanner.Text()))
    }
    if err := scanner.Err(); err != nil {
        fmt.Fprintln(os.Stderr, "error:", err)
        os.Exit(1)
    }
}

func main() {
    if len(os.Args) > 1 {
        f, err := os.Open(os.Args[1])
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
            os.Exit(1)
        }
        defer f.Close()
        filter(f)
    } else {
        filter(os.Stdin)
    }
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Line filters are the building blocks of shell pipelines - a Go binary that reads stdin and writes stdout composes with `grep`, `awk`, and `jq` without extra plumbing. If you wrap `os.Stdout` in a `bufio.Writer` for performance, call `w.Flush()` before `os.Exit` or returning from main - the OS flushes `os.Stdout` on normal process exit, but buffered writes in a `bufio.Writer` are not automatically flushed. Write errors to `os.Stderr`, not `os.Stdout`, so they do not corrupt the output stream in a pipeline. Exit with a non-zero code on error (`os.Exit(1)`) so downstream tools and shell scripts can detect failure. `bufio.Scanner` has a 64 KB default line limit; call `scanner.Buffer` before the first `Scan` if your input lines can exceed that.
</InProduction>


Reading from os.Stdin with bufio.Scanner, writing to os.Stdout, processing lines with strings operations, and the Unix filter pattern.

Line Filters


The `os` and `bufio` packages provide file reading at different granularities. `os.ReadFile` reads a whole file at once; `bufio.Scanner` reads line by line without loading the full file into memory.

<ExamplePair>
<ExampleProse>

`os.ReadFile` reads an entire file into a `[]byte` in one call. It opens, reads, and closes the file for you. Suitable for config files, small assets, and test fixtures - anything with a known bounded size.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    data, err := os.ReadFile("go.mod")
    if err != nil {
        panic(err)
    }
    fmt.Printf("read %d bytes\n", len(data))
    fmt.Println(string(data[:64])) // print first 64 bytes
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

For large files or line-oriented processing, open the file with `os.Open` and wrap it in a `bufio.Scanner`. The scanner reads one line at a time, keeping memory usage constant regardless of file size.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    f, err := os.Open("go.mod")
    if err != nil {
        panic(err)
    }
    defer f.Close()

    scanner := bufio.NewScanner(f)
    lineNum := 0
    for scanner.Scan() {
        lineNum++
        fmt.Printf("%3d: %s\n", lineNum, scanner.Text())
    }
    if err := scanner.Err(); err != nil {
        panic(err)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`os.Stdin` implements `io.Reader`, so the same `bufio.Scanner` pattern reads from standard input. This is the basis of Unix-style filter programs that accept piped input.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        line := scanner.Text()
        fmt.Println(strings.ToUpper(line))
    }
    if err := scanner.Err(); err != nil {
        fmt.Fprintln(os.Stderr, "read error:", err)
        os.Exit(1)
    }
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
`os.ReadFile` loads the entire file into memory - fine for configs and test fixtures, unsafe for unbounded user uploads or large log files. For large or streaming reads, open with `os.Open` and wrap with `bufio.Reader` or `bufio.Scanner`. Always call `defer f.Close()` immediately after a successful `os.Open` - not after the error check, not at the end of the function, but on the very next line so it is never accidentally omitted. `bufio.Scanner` has a default line buffer of 64 KB; if you expect lines longer than that (e.g. minified JSON), use `scanner.Buffer(make([]byte, maxSize), maxSize)` before the first `Scan()`. Check `scanner.Err()` after the loop - a scanner that runs out of input and a scanner that encounters a read error both exit the loop, but only one is an error.
</InProduction>


os.ReadFile for small files, os.Open with bufio.Scanner for line-by-line reading, the io.Reader interface, and reading from stdin.