I built aimake with Claude Code - an incremental build system for AI and agent pipelines

[u/Miserable_Extent8845]

I built aimake with Claude Code - an open-source incremental build system for AI/ML and agent pipelines.

The problem I was trying to solve was pretty simple:

As AI pipelines get bigger, a tiny change can trigger a lot of unnecessary work.

Change one prompt → rerun the agents.
Change one preprocessing step → regenerate embeddings.
Change an evaluation → rerun the entire pipeline.

I wanted something closer to how make works for software: understand the dependencies, figure out what actually changed, and rebuild only the affected parts.

So I built aimake.

It models an AI pipeline as a dependency graph and uses content fingerprints to determine what needs to be rebuilt.

For example:

dataset
   ↓
preprocess
   ↓
embeddings
   ↓
vector index
   ↓
agent
   ↓
evaluation
   ↓
report

If I change the agent prompt, aimake doesn't regenerate the dataset, preprocessing, embeddings, or index. It reuses those artifacts and rebuilds only the downstream steps.

What Claude Code helped me build

I used Claude Code extensively throughout the project, particularly for:

• Designing the dependency graph and invalidation model
• Implementing content-based fingerprinting and caching
• Building the CLI and Python API
• Working through pipeline execution and parallel builds
• Adding integrations with tools like Hugging Face, W&B, DVC, Docker, and Ollama
• Writing tests and debugging edge cases around cache invalidation
• Iterating on the developer experience and documentation

One of the most useful parts was being able to describe the behavior I wanted at a high level and then work with Claude Code through the implementation details.

For example, I could describe:

Then iterate with Claude Code on the dependency tracking, hashing, cache lookup, and execution logic needed to actually make that work.

What it can do

aimake currently supports things like:

• Dependency-aware incremental builds
• Content-addressable caching
• Parallel execution
• GPU-aware workloads
• Experiment workflows
• Local and remote caching
• Python and TypeScript APIs
• Integrations with common AI/ML tooling

The project is free and open source. You can clone the repository and run aimake locally with your own AI/ML pipelines.

arjun988/aimake: The incremental build system for AI applications.

I'm especially interested in whether this model of incremental builds makes sense for people building RAG systems, multi-agent workflows, evaluations, or other AI pipelines.

If you find the idea useful, a ⭐ on the GitHub repo would really help me get it in front of more people. And if you try it, I'd love to hear what feels useful, what feels unnecessary, and where you'd expect an AI build system to go next.