DEV Community: Salnik a

I got tired of my coding agent re-reading the same command output, so I built Dejavu

Salnik a — Tue, 07 Jul 2026 16:19:38 +0000

If you drive a terminal coding agent (Claude Code, Codex, Cursor's agent, Aider, opencode, Gemini CLI), you've probably watched it do this:

Run pnpm test. 40 lines of output. One test fails.
Change something unrelated.
Run pnpm test again. The same 40 lines. The same failure.
Repeat five more times.

Every one of those reruns dumps the full output back into the agent's context. But the information the agent actually needs is the delta: did the failure change? The rest is noise it has already seen.

I kept hitting the same thing with git diff, rg, build logs, and typechecks too. And prompting the agent to "not reread unchanged output" doesn't reliably work. So I built Dejavu, a command-output memory layer for coding agents.

The idea: run the real command, print only what's new

Dejavu is a PATH shim. You launch your agent through it:

dejavu start claude

That prepends a shim directory to PATH. Now when the agent runs pnpm test:

agent runs:      pnpm test
PATH resolves:   <dejavu-cache>/shims/bin/pnpm
shim runs:       dejavu run --shim-name pnpm -- test
Dejavu runs:     the real pnpm found later in PATH
Dejavu stores:   redacted stdout, stderr, metadata, exit code
agent receives:  first output, "unchanged" notice, or a compact delta

The agent doesn't know Dejavu exists. It keeps running ordinary commands. Dejavu just remembers what each command printed last time.

What the agent sees

Identical rerun:

dejavu: output unchanged since run 8c51f73.
Command: pnpm test
Exit code: 1
Suppressed ~4,820 estimated tokens.
Full output: dejavu show b92d1aa --stdout

Small change:

dejavu: output changed since run b92d1aa.
Changed lines:
- expected 403, received 200
+ expected 403, received 500

The command ran all three times. Only the display changed.

The part I care most about: it never skips execution

The fear with anything in your PATH is that it silently caches and hands your agent stale results. Dejavu doesn't. The invariant:

It always runs the real underlying command.
It always preserves the real exit code.
Full output is stored locally and always recoverable: dejavu show latest --stdout.
It only optimizes command shapes it recognizes as safe: test runners, tsc/eslint, read-only git (status/diff/log/show), rg/grep, find, docker logs. Anything it can't confidently classify passes through untouched.
Mutating commands (git commit, git push, installs, docker build, watch modes) pass through.
DEJAVU=off pnpm test bypasses it for one command.
Nothing is sent to a server. The cache is local.

It's not a cache in the "skip work" sense. It's a memory layer for what got printed.

Does it actually help? Early numbers

I want to be precise, because it's easy to overclaim. The built-in suite (dejavu bench) runs the real classify + reduce pipeline over deterministic scenarios:

Scenario	Agent reads without	with Dejavu
js validation loop (5x test)	5,561	2,443 (-56%)
git workflow (diff, 40 files)	10,329	954 (-91%)
search loop (rg, 180 matches)	9,346	644 (-93%)
large build log (40k lines x2)	1,057,554	241
machine-readable git	equal by design	equal

And in ~12 real Codex sessions: 52-55% less intercepted output, and ~87% in repeated local rerun loops.

Important caveat: that's reduction on the outputs Dejavu touches, not a claim about your total token spend. The strongest effect is in rerun loops. The benchmark is reproducible on your machine, and CI fails if the numbers regress (dejavu bench --check).

Try it

# no install
npx @salnika/dejavu start codex

# or
brew tap Salnika/dejavu && brew install dejavu
cargo install dejavu-cli

Then:

cd my-project
dejavu start claude

Rust, MIT, macOS/Linux/WSL (no native Windows yet). Everything is on GitHub: https://github.com/Salnika/dejavu

If you try it, the feedback I'm most after: command shapes where the delta hides something you actually needed, and any case where the classifier reduced something it shouldn't have. Those reports are the most valuable thing right now.

Phantom API: The Backend That Actually Gets Out of Your Way

Salnik a — Sun, 10 Aug 2025 12:33:39 +0000

Phantom API: The Backend That Actually Gets Out of Your Way

Hey there! 👋

If you're a frontend developer like me, you know the struggle. You just want to build cool features, but instead you're stuck writing boilerplate backend code, setting up database schemas, and configuring API endpoints. Sound familiar?

That's exactly why I got excited about Phantom API. It's this open-source backend system that basically reads your mind (okay, not really, but close enough). You make API calls from your frontend, and it automatically creates the endpoints, database tables, and validation rules you need. No joke.

What makes it actually useful?

Here's the thing - instead of spending hours setting up your backend, you literally just start coding your frontend. When you send data to an endpoint that doesn't exist yet, Phantom API goes "Oh, you need that? Let me create it for you."

It figures out relationships between your data (like when a post belongs to a user), sets up the right database constraints, and even gives you TypeScript support so you don't break things in production. Plus, there's a slick admin panel where you can see everything that's happening.

Getting it running is stupidly simple:

First, grab the dependencies:

yarn install

Copy over the environment config:

cp .env.example .env

Tweak your .env file with your details (you know the drill):

PORT=3000
NODE_ENV=development
JWT_SECRET=your-secret-key
DB_PATH=./data/phantom.db
ADMIN_EMAIL=admin@example.com
ADMIN_PASSWORD=admin123

Fire it up:

yarn pm2:start

And then just use it in your code like this:

import { setEndpoint, setToken, resource } from 'phantom-api';

setEndpoint('http://localhost:3000');
setToken('your-jwt-token');

const users = resource('User');
await users.create({ email: 'test@example.com', name: 'John Doe' });
const allUsers = await users.read();

Where this really shines:

I've seen people use it for all sorts of projects:

Building e-commerce sites without the usual database headaches
Throwing together social apps where you need users, posts, comments - all that jazz
Creating project management tools on the fly
Setting up content management systems without the typical complexity

Want to learn more or help out?

The whole thing is open source, which is awesome. If you want to dig deeper, contribute, or just see how it works under the hood:

Check out the NPM Package
Browse the Documentation
Star it on GitHub (you know you want to)

Honestly, if you're tired of wrestling with backend setup and just want to build stuff, give Phantom API a shot. It's one of those tools that makes you wonder why we've been doing things the hard way for so long.

Streamline Your Backend Development with the Simple NestJS Boilerplate

Salnik a — Mon, 19 Jun 2023 09:44:52 +0000

Article Title: Streamline Your Backend Development with the Simple NestJS Boilerplate

Introduction

The early stages of backend development often involve a lot of setup and configuration, which can slow down progress on the actual functionality of your application. Wouldn't it be great to jumpstart this process and focus more on writing the code that matters to your project? That's where boilerplates come into play. Today, I'm going to introduce you to a simple yet effective NestJS boilerplate that can help you kickstart your backend projects in no time.

The NestJS Boilerplate

The NestJS boilerplate is a bare-bones yet powerful project template designed to speed up the setup process for your NestJS applications. It includes pre-configured Swagger for API documentation, a Postgres database for data storage, Typeorm for interacting with the database, and a Dockerized app and database setup for easy deployment. You can find it on Github

The goal of this boilerplate is to remain simple and effective, allowing developers to get their projects off the ground quickly without getting bogged down in setup.

Features

This NestJS boilerplate comes with the following key features:

Swagger Documentation: Helps you design, build, document, and consume your APIs.
Postgres Database: A powerful, open-source object-relational database system that uses and extends the SQL language.
Typeorm: An ORM that can run in NodeJS and can be used with TypeScript and JavaScript.
Dockerized App and DB: A docker setup for both the app and the database to make deployments a breeze.

Getting Started

Setting up with this boilerplate is quite straightforward. First, ensure you have the following prerequisites installed on your machine:

NodeJS 18.10
Yarn
Docker
Docker-compose

Next, install the dependencies by running:

yarn install

To start the app and Postgres database, run:

docker-compose up --build

The app will be available on port 3000: http://localhost:3000

API Documentation

Your API documentation is available at http://localhost:3000/api. This documentation is powered by Swagger, making it interactive and easy to navigate.

Database Migrations

This boilerplate uses TypeORM to manage database migrations. To create a new migration or run existing migrations, use the following commands respectively:

yarn run migration:create ./src/migration/NAME_OF_THE_MIGRATION
yarn run migration:run

Contributions

Contributions are always welcome! Please check out the 'issues' tab on the GitHub page to find something you'd like to work on.

Companion Frontend NextJS Boilerplate

If you need a frontend solution to pair with this NestJS boilerplate, a simple NextJS boilerplate is also available. It's designed to work seamlessly with this backend boilerplate, providing a complete full-stack solution for your projects. Check it out on GitHub

Kickstart Your Project with the Simple NextJS Boilerplate

Salnik a — Mon, 19 Jun 2023 09:11:42 +0000

Introduction

Building a web application from scratch can be a daunting task, especially when time is of the essence. Setting up the environment, installing dependencies, and configuring the project often takes a significant amount of time before we even start working on our app's actual business logic. Wouldn't it be great if we could skip that step and jump straight into coding?

With boilerplates, we can do exactly that. They provide a pre-configured template that we can clone and start building upon immediately. They eliminate the need for setting up a project from scratch, thereby saving us precious time. In this article, I'm going to introduce you to a simple NextJS boilerplate project that is perfect for those looking to kickstart their project with minimal setup.

The NextJS Boilerplate

The NextJS boilerplate is a simple, yet powerful, starting point for your NextJS projects. It comes pre-configured with Redux for state management and Axios for promise-based HTTP requests, providing you with the fundamental tools to build dynamic and interactive web applications.

This boilerplate aims to stay simple and clean, enabling developers to get started with their projects swiftly and without unnecessary complexity. It's still a work in progress, but the goal remains the same: to make project setup as simple and quick as possible. You can find it on Github

Features

This NextJS boilerplate includes the following key features:

Next.js: A React.js framework that enables server-side rendering and generating static websites, making your web applications faster and SEO-friendly.
Redux Toolkit: This is a set of tools that reduces the amount of code needed to use Redux, making state management in your applications a breeze.
Axios: A promise-based HTTP client that works in the browser and Node.js, allowing your application to interact with APIs smoothly.

Getting Started

Getting started with this boilerplate is easy. First, you'll need to clone the repository to your local machine using the following command:

git clone https://github.com/salnika/nextjs-boilerplate

Once you've cloned the repository, navigate into the directory and install the dependencies:

cd next-boilerplate
yarn install

And voila! You can start the development server with:

yarn run dev

This will start a local development server. You can open your browser and navigate to http://localhost:3000 to see the result.

Documentation

Detailed documentation for Next.js, Redux Toolkit, and Axios can be found at the following links:

Contributions

Contributions to improve this boilerplate are always welcome! You can check out the 'issues' tab on the GitHub page to find something you'd like to work on.

Companion Backend nestJS Boilerplate

If you're looking for a backend solution to complement this NextJS boilerplate, there's also a simple NestJS

boilerplate available. It's designed to work seamlessly with the NextJS boilerplate, providing a full-stack solution for your project needs. Check it out on GitHub.

Conclusion

Getting started with your NextJS project has never been easier. This boilerplate provides a quick and simple way to start building your web applications without the need for extensive setup. Whether you're a seasoned developer or a beginner, you'll find this boilerplate incredibly useful to kickstart your projects.

Remember, the goal of this boilerplate is simplicity. As you work on your project, strive to keep the codebase clean and straightforward. Happy coding!

License

This project is licensed under the MIT License, meaning you're free to use, modify, and distribute it as you see fit.