I've built a lot of projects in Python, Go, and Rust.Because of that, I keep reusing the same kinds of code over and over:

• chunked pandas CSV processing
• health check endpoints
• retry wrappers
• validation helpers
• rate limiting
• small bits of glue code that are easy to forget and annoying to rewrite

The problem is not that I don't have this code.

The problem is that it is spread across a bunch of repositories.

So the real workflow usually looks like this:

1. I remember that I solved this before.
2. I don't remember which repo it was in.
3. I search for it.
4. I find three or four similar versions.
5. I spend time figuring out which one is the version I actually trust.

That last step is the annoying one.

Search gives me matches, not confidence

Code search helps, but only up to a point.

If I search for a CSV process, I might find:

• one version from an old script
• one version that was written fast and never reused
• one version that depends on some project-specific utility
• one version that is probably right, but I need to open more files to be sure

This is not a huge problem once.

It becomes a problem when the same pattern shows up every week.

I don't really need code that looks similar.
I need the version that already survived real usage.

For example, if I need to process a huge CSV file, I usually don't want a model to generate a fresh pandas implementation.

I want the chunked version I already used successfully before.

Something closer to this:

from typing import Callable

import pandas


def process_csv_in_chunks(
    csv_path: str,
    chunk_processor: Callable[[pandas.DataFrame], object],
    chunk_size: int = 10000,
) -> list[object]:
    """Read a CSV in chunks and return one processed result per chunk."""
    # Flow:
    #   CSV reader -> yield one chunk at a time
    #                 |
    #                 +-> empty chunk -> skip it
    #                 `-> non-empty chunk -> process it and collect one result
    if isinstance(chunk_size, bool) or not isinstance(chunk_size, int) or chunk_size <= 0:
        raise ValueError("chunk_size must be a positive integer")

    results = []
    chunk_iter = pandas.read_csv(csv_path, chunksize=chunk_size)

    for chunk in chunk_iter:
        if chunk.empty:
            continue
        results.append(chunk_processor(chunk))

    return results


if __name__ == "__main__":
    def to_rows(chunk: pandas.DataFrame) -> list[dict[str, object]]:
        return chunk.to_dict(orient="records")


    result = process_csv_in_chunks("your_file.csv", to_rows)
    print(result)

Not because this code is hard to generate.Because I already have a version I trust.

So why write it again?

This changed how I use AI for coding

I still use AI a lot.

For open-ended work, it is great.

If I'm exploring an API, sketching a feature, or comparing approaches, generation is exactly what I want.

But for well-defined work, I increasingly want a different workflow:

1. find the code I already trust
2. give that to the model
3. let the model adapt it

That is a much better fit for how I actually work.If I ask:

write Python code to process a large CSV in chunks

I will probably get something reasonable.

If I ask:

find my existing chunked pandas CSV snippet and adapt it to aggregate these columns

I am much closer to what I actually want.

That is the difference between generation and retrieval.

For a lot of day-to-day engineering tasks, retrieval is the more useful first step.

The real issue is not storage

This is not just a snippet storage problem.

Saving code is easy. Most of us already do it in some form:

• old repos
• scratch repos
• notes
• gists
• dotfiles
• random folders called utils-old or experiments

The hard part is making that code easy to retrieve later with enough context to trust it.

For me, that means I need at least:

• a short summary of what the snippet is for
• enough tags or metadata to separate similar snippets
• the actual code
• some confidence that this is the version I meant to keep

Without that, I am back to digging through old repos and guessing again.

Why I built AnySnippet

I wanted a desktop snippet workspace where I could keep these trusted pieces outside the repos where they were originally written.

And I wanted AI tools to be able to search that library through MCP.

The goal was not "generate more code faster".

The goal was much simpler:

when I already solved a problem before, help me reuse that solution instead of recreating it

That is the whole thing.

Not smarter autocomplete.
Not autonomous agents.
Not replacing engineering judgment.

Just a better path from:

I know I already wrote this

to:

here is the version I trust, now adapt it to the current job

What I actually wanted from the tool

I wanted a few very boring things:

• one place for reusable code across Python, Go, and Rust
• search that is scoped to code I intentionally kept
• enough metadata to disambiguate similar snippets
• a way for Claude or Codex to retrieve those snippets directly
• a workflow that feels local and practical, not like publishing content to a platform

That is why I ended up with a desktop workspace instead of just another repo.

A repo is great for versioned code.

It is less great as a personal retrieval layer when what I want is "find the thing I trust and hand it to the model".

What changed after I started using this approach

The main difference is that I spend less time re-explaining old work to myself.

That is really it.

I still review generated code.
I still change things manually.
I still throw away bad suggestions.

But now, for repetitive and well-defined tasks, I can start from code I already believe in.

That is a much better starting point than a fresh answer that happens to look correct.

If you already feel this pain, you probably don't need more generation

You probably need a better retrieval layer.

That does not have to be AnySnippet.

Even if you build your own setup, I think the useful idea is the same:

• stop treating every solved problem as something that should be regenerated
• keep trusted reusable code somewhere deliberate
• make it easy to retrieve with context
• let AI adapt from there

For me, that has been a better default for real engineering work.

Especially for the boring stuff.

And honestly, the boring stuff is most of the work.

Question

How are you dealing with this today?

Are you mostly relying on repo search and memory, or do you already have some kind of personal library for trusted reusable code?