DEV Community: Tony Hui

A follow-up tracker with four fields and no server

Tony Hui — Thu, 05 Nov 2026 10:24:47 +0000

There is a failure mode that hits almost everyone who does work for other people, and it is not a technical one.

You finish the job, you send the invoice, and then the invoice disappears into a mental list you never wrote down. Three weeks later you remember it, and by then you are the one apologising for asking.

The usual fixes all fail for the same reason. A spreadsheet is never opened. A reminder app fires while you are in a meeting and gets dismissed. A Notion database is beautiful and costs three minutes of maintenance per item, so it is abandoned within a week. None of them are built around the actual object, which is not "a task" but "something another person owes you."

OweTrace is a small iOS app built on that premise. This post is about the design decisions, not the marketing, because the interesting part is what is deliberately absent.

The data model is intentionally boring

The core object is an Obligation. Four fields matter:

what - a short label, free text
kind - money, reply, document, or refund
dueAt - the date the other person said they would act by
nextNudgeAt - computed, never user-set

The last one is the only interesting decision. Users do not pick follow-up dates. The app derives them from a three-touch cadence: first nudge at two to four business days, second one a week later, third one a week after that, then a close-out.

Why compute rather than ask: any interface that makes a user pick a date produces one of two bad outcomes. Either the user picks "tomorrow" for everything, or the user picks nothing because the decision is a nuisance. Deriving it means the default is correct and the user only intervenes when a case is genuinely unusual.

No account, no sync, no server

This is the decision that looks wrong until you look at what is actually stored.

A follow-up tracker is exactly the kind of thing people want on both a phone and a laptop. But every sync story needs an account, and every account is a thing that can be breached, a password someone forgets, and a server somebody has to keep running and paying for.

The stored data is a list of what other people owe you. It is personal, it is not high-value, and it changes rarely. Local-only storage with a JSON export covers the real use case and removes an entire class of failure.

The tradeoff is real and worth stating plainly: no sync means losing the phone means losing the list, unless you exported. There is an export. Most people will not use it. For a first version that is still the right call, because the alternative cost is having no users at all while waiting for a backend to justify itself.

The reminder problem is a scheduling problem

iOS notifications look simple and are not.

A follow-up tracker has a specific shape: few items, each with few future trigger dates, all fully known at creation time. That maps cleanly onto UNCalendarNotificationTrigger, which the system schedules ahead of time. No push notifications, no background refresh budget, no server deciding when to wake the app.

What is needed instead is correct rescheduling when an item changes. If a nudge is marked sent, the next two triggers have to move forward by exactly one step of the cadence, not by a fixed interval from today. Getting this wrong produces a tracker that nags twice in one day and then goes silent for a month, which is worse than having no tracker at all.

The whole scheduling module is a pure function from [Obligation] to [NotificationRequest]. It is about a hundred lines, it has no side effects, and it is the part worth writing tests for first. Everything else in the app is presentation.

What this shape of problem teaches

Derive schedules, do not ask for them. A default that is right 80% of the time beats a picker that is right 100% of the time and used 20% of the time.
Make state exportable before making it syncable. Export is a day of work. Sync is a quarter.
Model the cadence, not the reminder. "Three touches then close out" survives a change in notification API; "schedule a notification for day 3" does not.
Do not build a social feature. A list of what people owe you is embarrassing information. Nobody wants to share it.

The app is free to start, with a Pro tier that unlocks unlimited active items. The longer write-up on follow-up timing, including the message templates, lives here:
https://taoapex.com/en/guides/general/how-long-to-wait-before-following-up/?utm_source=devto&utm_medium=social&utm_campaign=owetrace-followup-cadence&utm_content=article-01

Disclosure: OweTrace is built by TAOAPEX LTD, which also publishes that guide.

Stop Prompt Chaos: Build a Professional Prompt Workflow

Tony Hui — Mon, 12 Jan 2026 07:30:28 +0000

Most people don’t have a “prompt quality” problem. They have a prompt lifecycle problem: a great prompt gets created once, then lost, duplicated, and rewritten forever.

Here’s a lightweight system you can reuse across projects, teams, and models.

1) The Prompt Lifecycle (Draft → Enhance → Improve → Save → Reuse)

Treat prompts like assets (like code snippets or legal templates), not one-off messages.

Draft: Write the simplest version that expresses intent.

Enhance: Add clarity, constraints, and a fixed output structure.

Run: Test on real inputs (not toy examples).

Improve: Iterate with small, measurable changes.

Save: Store with metadata + sample input/output.

Reuse: Copy into the next task without starting over.

2) What a Prompt Enhancer Actually Does

A good prompt enhancer does three things:

Makes the goal explicit (what “good” looks like)

Adds constraints (what to avoid / what not to assume)

Locks output format (so results are usable downstream)

Before (vague): “Improve this onboarding email.”
After (structured): “Rewrite for first-time users; <170 words; calm tone; include value promise + 3-step list + privacy reassurance + single CTA label; avoid hype; mention ‘AI’ at most once.”

That’s the difference between lucky output and repeatable output.

3) Prompt Improver = Versioning Mindset (Like Pros)

Once a prompt is decent, stop rewriting from scratch. Improve like you’d optimize a landing page:

Change one thing at a time (tone OR structure OR constraints — not all)

Score with a simple rubric (Accuracy, Completeness, Usefulness, Style fit, Risk)

Keep version history (so you can compare and roll back)

This is how you build a dependable prompt library.

4) Model-Specific Variants (Claude vs GPT)

“One perfect prompt” is a myth. Different models respond differently, so create variants.

A practical Claude-friendly pattern:

Start with the job: “You are doing X.”

Add motivation: “This matters because Y.”

Provide one good example (avoid bad examples).

Specify output format + stop conditions.

5) Prompt Manager: Why Saving Prompts Isn’t Note-Taking

If you only save raw prompt text, you won’t trust it later because you’ll forget:

what it was for

what input it expects

which model it worked best on

what “good output” looks like

A real prompt manager helps with retrieval + reuse: tags/folders, full-text search, one-click copy, and version history.

6) Save Prompts as “Prompt Cards” (Template)

Use this compact format:

Prompt Card

Title:

Goal:

Audience:

Model: (GPT / Claude / other)

Inputs:

Constraints: (no invented facts/citations; ask questions if info missing)

Output format:

Example input:

Example output:

Version notes: (what changed + why)

7) Practical Prompt Packs (Copy/Paste)
A) ChatGPT prompts for self-improvement (5)

Weekly review
“Ask me 10 questions to surface what worked, what didn’t, and what I avoided. After I answer, summarize patterns and propose 3 changes for next week. Keep it direct.”

Habit design
“Help me build a habit for: [goal]. Give 3 options (easy/medium/hard). For each: trigger, action, reward, and recovery after a missed day.”

Decision clarity
“I’m choosing between [A] and [B]. Ask only the questions needed to clarify constraints (time, money, risk). Then recommend with reasoning + a ‘first 30 minutes’ action plan.”

30-day skill plan
“Create a 30-day plan to improve [skill], 30 minutes/day. Give daily tasks, weekly checkpoints, and one measurable outcome per week.”

Difficult conversation rehearsal
“Roleplay a conversation with [person] about [topic]. First ask for context. Then simulate their likely pushback. Help me respond calmly. End with a short script I can actually say.”

B) ChatGPT prompts for lawyer (5) + safety header

Safety header (paste above every legal prompt):
“Do not paste confidential client information. Use placeholders. Do not invent laws/cases/citations. If jurisdiction matters, ask first. Verify everything independently.”

Contract risk scan (structured)
“Review the clause below. Output: risk level; what it does; what could go wrong; suggested revision text; questions for the client.”

Clause rewrite (stance)
“Rewrite this clause to favor [buyer/seller/vendor/customer]. Provide two versions: ‘reasonable’ and ‘aggressive’. Explain tradeoffs in 5 bullets.”

Client email (plain English)
“Draft a client email explaining the issue in plain English (<180 words). Include: what it means, why it matters, recommendation.”

Interview/deposition outline
“Create an outline of questions to clarify facts for [issue]. Organize by topic and include follow-ups for evasive answers.”

Hallucination-resistant research helper
“State what you can conclude from the facts provided. Then list what you cannot conclude without external sources. If authorities are needed, provide a research checklist (not citations).”

8) Prompt Debugging Checklist

If outputs keep missing the mark, usually it’s because:

you didn’t define success (add acceptance criteria: include X, exclude Y)

the model is guessing missing context (force questions first)

your example teaches the wrong behavior

you needed a format, not “analysis” (lock structure)

you mixed tasks (split: generate → critique)

9) Where a Prompt Manager Pays Off Immediately

You’ll feel ROI fastest when you have:

Recurring work (emails, briefs, content frameworks, code reviews)

Multi-model workflows (GPT + Claude + image tools)

High-stakes domains (legal/finance/security) where versioning + guardrails matter