Building software with an amnesiac agent: notes on a resumable overnight build loop

Meela Dheeraj — Tue, 16 Jun 2026 06:35:13 +0000

I wanted to see how far an autonomous coding agent could get unattended. The constraint that makes this hard isn't code generation — it's that each session starts with zero memory of the last. So the design problem is state, not prompting.

Setup

A cron-scheduled task fires hourly, 11pm–7am (~8 runs).
Each run is a fresh agent session. No shared context, no carryover.
State lives entirely on disk: the working tree, the git history, and two files — BUILD_SPEC.md (the immutable goal/architecture) and PROGRESS.md (an append-only decision + status log).

The run loop
Every session does the same thing:

Read BUILD_SPEC.md, then PROGRESS.md, then git log --oneline.
Reconstruct "where are we" from the files themselves (the code is the source of truth, not the narrative).
Do one unit of work.
Commit. Append to PROGRESS.md: what changed, why (chosen X over Y because Z), and the exact next step.

Commit granularity = checkpoint granularity. Worst case on an interrupted session is losing one unit, and the next run re-derives it. The "why" lines matter as much as the diffs — without them a later session re-litigates settled decisions.

Guardrails
The agent was allowed to build, test, and commit locally. It was explicitly not allowed to deploy, push to a remote, or touch secrets — those get written into PROGRESS.md as "needs human" items instead. This boundary is what makes unattended runs safe to leave alone.

What came out
A working full-stack monorepo: a pure TS scheduling engine (with property tests), multi-tenant auth, a Drizzle/Postgres schema, server-side re-validation, and publish/share/export flows. Across the runs it cleared its own stale git lock, and one session caught and fixed an off-by-one in a labeling layer that spanned five files.

The takeaway
The leverage wasn't the model writing code. It was designing a process where progress is durable across total context loss — externalize state, checkpoint constantly, log decisions not just actions, and fence off irreversible operations.

Repo/stack details in comments. Curious how others are handling agent state across sessions — file-based like this, or something more structured?

Exploring Kotlin Multiplatform (KMP) as an iOS Developer 🚀

Meela Dheeraj — Sun, 14 Jun 2026 16:00:47 +0000

While exploring different approaches to cross-platform development, I recently came across Kotlin Multiplatform (KMP).

At first, I assumed it was another "write once, run everywhere" framework.

The more I learned, the more I realized that's not what KMP is trying to be.

Instead of sharing everything, KMP focuses on sharing the parts that are often duplicated across platforms:

✅ Business Logic

✅ Networking

✅ Data Layer

✅ Domain Models

while still allowing teams to build native user interfaces using:

🍎 SwiftUI on iOS

🤖 Jetpack Compose (or Views) on Android

A simplified architecture looks like this:

┌─────────────────────┐
│   Shared Module     │
├─────────────────────┤
│ Business Logic      │
│ Networking (Ktor)   │
│ Data Layer          │
│ Domain Models       │
└──────────┬──────────┘
           │
     ┌─────┴─────┐
     │           │
┌────▼────┐ ┌────▼────┐
│   iOS   │ │ Android │
│ SwiftUI │ │ Compose │
└─────────┘ └─────────┘

What I find interesting is that KMP doesn't force you to abandon native development.

Instead, it tries to solve a very specific problem:

Why maintain the same business rules, networking code, and data models in two different codebases?

Some areas I'm currently exploring:

• Project structure and source sets

• Shared vs platform-specific code

• Ktor for networking

• Dependency Injection

• Compose Multiplatform

• Interoperability between Swift and Kotlin

• Real-world production use cases

For developers already using KMP in production:

What has been the biggest advantage?
What challenges did you face during adoption?
Any lessons you'd share with someone getting started?

Looking forward to learning from the community and sharing my findings as I continue exploring KMP.

KotlinMultiplatform #KMP #Kotlin #iOS #SwiftUI #Android #JetpackCompose #MobileDevelopment #SoftwareArchitecture #CrossPlatform

DEV Community: Meela Dheeraj

Building software with an amnesiac agent: notes on a resumable overnight build loop

Exploring Kotlin Multiplatform (KMP) as an iOS Developer 🚀

KotlinMultiplatform #KMP #Kotlin #iOS #SwiftUI #Android #JetpackCompose #MobileDevelopment #SoftwareArchitecture #CrossPlatform