Give the Agent a Memory Before You Give It a Task

Andrew Detwiler — Mon, 13 Jul 2026 16:31:05 +0000

Every AI coding session starts the same way.

The agent knows nothing about your project. Not the decision you made last
Tuesday. Not the migration that burned you. Not the naming convention you
finally settled on.

So you re-explain. Every session. Or worse, you don't, and the agent makes
a mistake you already paid for once.

The fix is boring

It's not a smarter model. It's not a bigger context window. It's writing
things down, in the repo, where the work happens.

I keep three kinds of files in every serious project now:

A short operating manual the agent always loads. Rules only. If it grows past a page, something moves out.
Decision records. One small file per locked decision, with the why. The why is the part you forget first.
A gotchas file. Every time something non-obvious bites me, it gets a line right then. If I save it for later, it never happens.

That's it. Plain markdown. No tooling, no framework, nothing to install.

What changed for me

Honestly, the difference is bigger than any model upgrade I've tried.

A fresh session reads the manual and starts acting like it was here last week.
It follows conventions I never mentioned in the prompt. It skips the mistakes I already
made once, because they're written down.

And the strange part: the notes made me better too. Writing "we decided X
because Y" forces you to actually have a Y.

A starter file

Drop this in your repo as AGENTS.md and edit it honestly:

# Operating manual

## What this project is
One sentence. What it does, who it's for.

## Rules that are always true
- Commands: how to run dev, tests, build.
- The one or two conventions people keep getting wrong.

## Decisions (the why matters)
- 2026-07-12: We use X instead of Y because Z.

## Gotchas
- The thing that bit us, and what to do instead.

Start smaller than feels right. A pile of docs nobody maintains is worse than
one page that's true.

What are you writing down?

I'm still figuring out where the line is between useful memory and busywork.
If you're doing something like this in your own projects, I'd honestly love
to hear what you keep and what you throw away.

How I’m Building Personal Apps With AI, Next.js, SQLite, and Tailscale

Andrew Detwiler — Sun, 10 May 2026 02:04:02 +0000

For years, building custom software felt like something reserved for startups, funded teams, or companies with dedicated infrastructure.

That’s changing fast.

Today, you can build fully custom personal apps for yourself, your family, or a small team in an afternoon using AI. You don’t need cloud infrastructure. You don’t need Kubernetes. You don’t even need to deploy anything publicly.

You can run modern web apps entirely on your own machine or on a small dedicated computer in your house, securely, and install them on your phone like native apps.

I’ve been doing this myself for budgeting tools, meal planning apps, grocery lists, internal dashboards, and small tools that help organize things at home.

And honestly, it works incredibly well. Most of these apps would have never been worth building for me a few years ago.

The Shift Happening Right Now

The biggest change isn’t just AI generating code.

It’s that the combination of:

AI coding models
Modern frameworks like Next.js
SQLite
Progressive Web Apps (PWAs)
Tailscale

has lowered the barrier so much that building personal software is now practical for regular developers.

You no longer need:

AWS infrastructure
complicated authentication systems
production-grade distributed databases
app store deployments
expensive SaaS subscriptions for every tiny need

If your app is only for:

yourself
your family
your friend group
a small team
your local business

you can simplify almost everything.

And simplification changes the game.

What You’ll Need

The stack is intentionally minimal.

1. AI Coding Tool

You can use:

ChatGPT
Claude
Cursor
Windsurf
anything capable of generating and modifying code

This is really the only paid part depending on the model you use.

2. Next.js

Next.js is perfect for this.

You get:

frontend
backend API routes
server rendering
static assets
routing
PWA support

all in one project.

No separate backend required.

3. SQLite

For personal apps, SQLite is massively underrated.

You do not need Postgres for:

grocery lists
meal planners
budgeting apps
household management
internal dashboards
small team tools

SQLite gives you:

a single file database
zero infrastructure
no database server
extremely reliable storage
backups as simple as copying a file

And for personal applications, it’s more than enough.

4. Tailscale

This is what makes the whole thing practical.

Tailscale creates a private encrypted mesh network between your devices.

Your app never has to be exposed publicly to the internet.

You can:

host the app on your desktop
run it on a mini PC
keep it on an old laptop
use a small home server

and securely access it from:

iPhone
Android
Mac
Windows
tablets
laptops

Tailscale’s free tier supports up to 6 users, which is perfect for families or small teams.

This is honestly one of the biggest unlocks for personal software development.

The Authentication Trick

For personal apps, you don’t need enterprise auth.

You don’t need:

OAuth
Auth0
Clerk
JWT complexity
social logins

If the app only exists inside your private Tailscale network, you can simplify authentication dramatically.

One approach I use often:

create predefined users
let the app ask “Who are you?”
store the selected user locally
treat that as authenticated

That sounds wrong if you come from enterprise software.

But context matters.

Inside a private encrypted Tailscale network shared only with trusted users, this is often completely acceptable for personal tools.

The result:

almost zero auth complexity
no external auth provider
no monthly auth costs
much faster development

You stop overengineering software that only five people will ever use.

Make It a PWA

This part is important.

When prompting the AI to build the app, include:

installable PWA support
offline support where possible
responsive mobile UI
app manifest
service worker setup

This allows the web app to behave almost exactly like a native app.

You can install it directly from the browser.

iPhone

Use Safari → Share → Add to Home Screen

Android

Install directly through Chrome

Mac and Windows

Install directly from Chromium browsers

Once installed:

it launches like a native app
has its own icon
runs fullscreen
feels like a real application

Most non-technical users won’t even realize it’s a website.

Using MagicDNS

Tailscale’s MagicDNS makes the experience even better.

Instead of:

192.168.1.44:3000

You get:

mealplanner.tailnet-name.ts.net

Or:

budgetbox.tailnet-name.ts.net

This makes your apps feel like real products instead of random local servers.

Example Apps That Work Extremely Well

Family Apps

Meal Planner

weekly meals
shared grocery list
pantry tracking
recipe storage

Budgeting App

monthly expenses
sinking funds
subscriptions
shared family budgeting

Household Dashboard

chores
maintenance reminders
schedules
calendars

Kids Dashboard

allowance tracking
reading goals
homework tracking
screen time systems

Small Team Apps

Internal Tools

lightweight CRM
project tracker
sprint dashboard
client management

Studio Tools

asset trackers
bug lists
roadmap viewers
release planning

Content Pipelines

social post planners
publishing trackers
video pipelines

Why This Matters

We spent years forcing every software idea into:

SaaS
cloud hosting
subscriptions
scaling concerns
public deployment

But most software ideas do not need to scale to millions of users.

A huge percentage of useful software only needs to solve problems for:

one person
one family
one studio
one team

AI makes custom software generation cheap.

Modern frameworks make development fast.

Tailscale makes networking easy.

PWAs make distribution trivial.

And SQLite removes infrastructure entirely.

The result is that personal software development is entering a completely different era.

A Sample Prompt

Here’s the type of prompt I’ll give an AI model:

Build a Next.js PWA for meal planning and grocery management.
Use SQLite for storage.
Use simple local authentication where the user selects their identity from predefined users.
Design it mobile-first.
Add installable PWA support.
Include offline support for grocery lists.
Optimize the UI for iPhone and desktop usage.
Use TailwindCSS and shadcn/ui.
Structure the app cleanly with reusable components and API routes.

That alone can get you shockingly far now.

Final Thoughts

I think we’re entering a phase where developers will increasingly build software specifically for:

their own lives
their families
their friend groups
niche communities
small businesses

Not everything needs to become a startup.

Sometimes the best software is:

simple
private
local
highly customized
built for exactly the people using it

And for the first time in a long time, building those kinds of applications is actually easy.

What Are You Building?

If you’ve been building personal apps or experimenting with local-first setups, I’d honestly love to hear what you’re building or how you’re approaching it.

I think this space is becoming more interesting every month.

DEV Community: Andrew Detwiler