Overview of I Built an AI Assistant That Works While I Sleep
Chris Hutchins explains how—despite not being a software engineer—he built a persistent AI assistant (named “Ted”) that runs 24/7, performs scheduled tasks, and automates real, daily workflows (morning briefings, card/referral tooling, finances, and more). The episode walks through his projects (from a simple referral-link rotator to a full credit-card optimizer app), the tools and architecture he used, what Ted actually does overnight, costs/risks, and practical advice for non‑technical builders who want to try this themselves.
Major takeaways
- Building useful AI-enabled apps is much more accessible than before: you can go from idea → working prototype in hours or days using no-setup platforms.
- Start small and solve a real personal friction (not “build a company” first). Compound features over time.
- Persistent assistants (agents running on a machine or cloud) can proactively do scheduled work, but they bring security and cost trade-offs.
- You don’t have to be an engineer—being a good specifier/product manager (clear requirements, documentation) is the critical skill.
What Chris built (projects & examples)
- Referral-link rotator (allthehacks members)
- Hosted member referral links, rotated links, tested link validity, sent alerts, and rewarded members; generated millions of points for members.
- Credit-card optimizer → real app
- Replaced his complex Google Sheets with an app: wallet, multi-person “players” (spouse/kids), earning rules database, credits tracking (e.g., Aura, digital entertainment), statement & utilization alerts, overdraft forecasting, and points/balances tracking.
- Features include automatic detection of credits from transaction feeds and a TamperMonkey/browser-extension import for airline/hotel point balances.
- Scale: ~109 database tables and ~2,200 lines of optimization logic.
- Persistent AI assistant “Ted”
- Runs scheduled tasks (cron-like), compiles morning briefings (sleep, calendar, weather, car charge), scans blogs, Reddit, Twitter for relevant items, triages card-tool feedback, flags travel/transfer bonuses, and more.
- Ted can speak via voice notes, respond, and be interviewed on the podcast.
Tech stack & tools he used
- Rapid prototyping platforms:
- Replit (easy browser-based start; low cost for small projects)
- Cursor (more advanced; allowed multiple agents)
- Cloud Code / Cloud tooling (used for refactoring and reusable components)
- OpenAI Codex (mac app just launched at time of episode)
- Lovable, other newcomer low-code/no-code developer tools (examples mentioned)
- Speech / transcription:
- Whisperflow (audio planning/transcription)
- Integrations & infra:
- Plaid (bank/account aggregation)
- Supabase, Clerk (examples of authentication / DB hosting)
- TamperMonkey (browser script for importing balances)
- Persistent assistant frameworks:
- Claudebot / OpenClaw (rebranded; runs agents on a computer/cloud)
- Hosting:
- Cloud VPS (recommended) or an isolated local machine (he used a wiped 2012 Mac Mini)
- Databases / code:
- He used local directories + tools’ ability to read project files for context; refactoring with Cloud Code improved reuse.
What Ted (the assistant) actually does — sample daily workflow
- Scheduled maintenance: self-updates/patches overnight.
- Morning briefing: compiles sleep score, calendar highlights, weather, Tesla charge level, dinner/meal plan + groceries, overnight email summary.
- Content discovery: scans targeted blogs (Doctor of Credit, The Points Guy, Frequent Miler), Twitter, Reddit for relevant news (e.g., Capital One → JAL transfer bonus).
- Product support: triages feedback/issues for the card tool, files GitHub issues.
- Finance & card management: flags credits to use, tracks balances and upcoming statement closings, warns about high utilization and potential overdrafts.
- Automations: can run cron jobs, write integrations, respond by voice, and proactively suggest actions.
Ted’s known failure modes:
- Ambiguity in instructions → sometimes acts on the wrong interpretation
- Expired auth tokens → can silently stop working (no morning briefing)
- Over-eagerness to act on projects Chris didn’t request
- Occasional factual checks or false positives
Costs, limits, and security considerations
- Costs:
- Model usage can get expensive. Chris estimates $1,000–$1,500 spent during development; he believes smarter model choices could have reduced that ~90%.
- Platform subscription costs: Replit and similar tools are modest (hundreds/year for his usage); Claude subscription example: $200/month.
- Tip: heavy use of high-end models (Opus 4.5, GPT-4-family) quickly increases bills—monitor usage and mix cheaper models for routine tasks.
- Security:
- Don’t run a persistent assistant on your primary machine with full access. Use cloud servers or virtual machines for isolation.
- Limit permissions initially (give read-only or separate account access), and escalate trust gradually.
- Marketplace “skills” can be risky—some have hidden malware; be cautious before installing third‑party skills.
- Watch auth tokens: implement token refresh handling and fail‑safe behavior so the assistant notifies you if a connection dies.
- Maintenance overhead:
- Building is fast; running a production software product (bugs, support, feature requests) is work Chris doesn’t necessarily want to take on.
Practical lessons & recommendations
- Start with one small, personal problem and build a minimum viable automation (e.g., put meal plans on your calendar via Zapier).
- Be a product manager: document requirements, ask the tool planning questions, and insist on step-by-step plans before “run”.
- Break big projects into smaller pieces and ask the tool to document each step so knowledge isn’t lost.
- Add integrations incrementally: calendar → email → bank → other services.
- Monitor model and platform costs and pick cheaper models for routine tasks; upgrade plans only when usage justifies it.
- Expect a learning curve: things will break, and training the assistant to your preferences takes time.
- Security first: isolated host, limited credentials, and cautious installation of third-party skills.
How to get started (simple action plan Chris suggests)
- Write down three tools/products/ideas you wish existed to solve friction in your life or business.
- Pick an easy platform (Replit, Lovable, Cursor) and build the simplest version that solves one of those problems.
- Start with one integration (e.g., calendar) and live with it for a week before adding email or bank connections.
- Ask your AI tool to document the plan and code as you build—this creates the knowledge base for future tooling or migration.
- Track cost and usage; if you get hooked, explore more advanced tools (Cloud Code, Codex) and run the assistant on a secure host.
Notable quotes / sound bites
- “If you have an idea and you want to see it come to life, anyone with that feeling in a few hours could end up with a working prototype.”
- “The real unlock isn’t the technology. It’s clarity about what you actually want.” — Ted (the assistant)
- “It’s not should you learn to code, it’s what would you build if building were easy?”
Final verdict (summary)
This episode is part inspiration, part practical how-to. Chris demonstrates that non-technical creators can rapidly prototype and iterate meaningful automations and full products using modern AI tooling, but he also warns about security, costs, and the maintenance burden. His core advice: start small, be specific, document, and scale deliberately. If you want to explore building your own assistant, this episode provides a realistic, experience-based roadmap and concrete next steps.