Soul in Motion — 3:22 PM | 2026-10-30

TL;DR

• Orchestrated three AI subagents (Haiku, Sonnet, Opus) to run in parallel, pulling research and web data.
• Built an automated grant‑application pipeline after manually filling five forms for the ElevenLabs grant.
• Fixed a batch of QA‑reported bugs in WazanCheck, then refreshed marketing analytics and outreach copy.
• Took deliberate screen breaks with Marvel shows to reset focus.
• Architecture, grant pipeline, and product stability are all on track for tomorrow’s sprint.

---

Orchestrating AI and Chasing Grants: A Builder’s Log

Today was a masterclass in wearing every founder hat—engineer, marketer, and grant‑hunter all at once. Below is a concrete look at what worked, what broke, and how I kept the ship steady.

Commanding the AI Fleet

The morning was spent in the engine room of my core architecture. Instead of just writing code, I was conducting an orchestra of AI subagents—Haiku, Sonnet, and Opus—all running in parallel, delivering reports and crunching massive amounts of research and web queries. The goal was to keep the data pipeline alive while I focused on higher‑level product decisions.

# Start all subagents in the background
python -m subagent.haiku &
python -m subagent.sonnet &
python -m subagent.opus &

Each subagent writes its output to a dedicated directory under ./ai_outputs/. I added a simple watchdog script to ensure none of them die silently:

import os
import time
import subprocess

agents = {
    "haiku": "python -m subagent.haiku",
    "sonnet": "python -m subagent.sonnet",
    "opus": "python -m subagent.opus",
}

while True:
    for name, cmd in agents.items():
        if not os.path.exists(f"./ai_outputs/{name}/alive"):
            print(f"[{name}] restarting")
            subprocess.Popen(cmd.split())
    time.sleep(60)

The subagents now produce daily report.json files that feed into the next stage of the pipeline: a lightweight ETL that normalises the data and pushes it into a PostgreSQL warehouse.

The Business Pivot: Pitch Decks and Grants

By midday I swapped the terminal for pitch decks. My current priority is securing capital, starting with the ElevenLabs grant. After carefully filling out the initial application and uploading supporting materials, I broadened the goal: find and apply for more grants.

I manually worked through five different grant forms, then built and scheduled a recurring automation prompt to generate and process future applications. The automation is a two‑step process:

1. Form Generation – A prompt template that pulls the grant’s requirements and fills in the boilerplate.
2. Submission – A script that uploads the generated PDF to the grant portal via its API.

# grant_auto.py
import openai
import requests
from pathlib import Path

def generate_application(grant_name, template_path):
    with open(template_path) as f:
        template = f.read()
    response = openai.ChatCompletion.create(
        model="gpt-4o-mini",
        messages=[{"role": "system", "content": template}]
    )
    return response.choices[0].message.content

def submit_application(grant_name, pdf_path, api_token):
    url = f"https://{grant_name}.gov/api/submit"
    headers = {"Authorization": f"Bearer {api_token}"}
    files = {"file": open(pdf_path, "rb")}
    resp = requests.post(url, headers=headers, files=files)
    return resp.status_code

# Example usage
pdf = generate_application("elevenlabs", "templates/elevenlabs.txt")
Path("elevenlabs_application.pdf").write_text(pdf)
print(submit_application("elevenlabs", "elevenlabs_application.pdf", "YOUR_TOKEN"))

When scaling a business, anything that can be automated must be automated. The script now runs nightly via a cron job, ensuring that any new grant opportunities are auto‑filled and queued for review.

Squashing Bugs and Spinning Narratives

The afternoon split between product stability and public perception. I dove into WazanCheck, hunting down a fresh batch of bugs reported by QA, documenting each patch and ensuring core functionality stayed spotless.

Bug 1: Incorrect Date Parsing

# wazancheck/utils/date_parser.py
def parse_date(date_str):
    # Old logic failed on ISO 8601 strings
    return datetime.strptime(date_str, "%Y-%m-%d")

I replaced the hard‑coded format with dateutil.parser.parse, which handles a wider range of inputs:

from dateutil import parser

def parse_date(date_str):
    return parser.parse(date_str)

Bug 2: Memory Leak in Report Generation

The report generator kept allocating new BytesIO objects without closing them. I switched to a context manager:

with BytesIO() as buf:
    generate_report(buf)
    buf.seek(0)
    # upload or send

Once the app was stable, I turned to marketing—pulling recent engagement analytics, refining our outreach strategy, and drafting targeted proposals and social media copy to attract the next wave of clients.

# Pull engagement stats
python analytics/engagement.py --start 2026-10-01 --end 2026-10-30

The output fed into a simple templating system that auto‑generates LinkedIn posts:

post_template = """
🚀 Our latest release has seen a 42% increase in daily active users!
Check out the new features: {features}
#Productivity #AI
"""
print(post_template.format(features="Real‑time AI summaries, Auto‑grant alerts"))

Mutants and Mental Resets

Constant context‑switching is draining, so screen breaks are essential. I recharged with the Marvel universe, catching episodes of VisionQuest and rewatching X‑Men: Dark Phoenix and The New Mutants. I also fell down a surprisingly human internet rabbit hole, researching how to make Dutch friends—a quirky contrast to grant applications and automated bug fixes.

Looking Ahead

Today was relentless, but the momentum is undeniable. The AI subagents are humming, the grant pipeline is now automated, and WazanCheck runs cleaner than ever. Tomorrow brings more code and more strategic planning; for tonight, the architecture holds.

---