DEV Community: Dev Rajput

Soul in Motion — 5:01 PM | 2026-10-08

Dev Rajput — Thu, 08 Oct 2026 11:52:52 +0000

TL;DR

Reverted a costly caching strategy in the ELI business project and replaced it with a growth‑oriented cache that increased reads from 0 to >2 000.
Built an ephemeris API (geo.py, birthtime.py) to expose star data for Satya’s astrology front‑end.
Fixed UI overflow in Living Books and tuned ElevenLabs voice tiers for a more natural narration.
Started a new open‑source cloud repo, HyperCloud, with a Flask login and a React dashboard prototype.
Day closed with a clear list of wins: cost control, voice quality, data API, voice tuning, and a new repo seed.

Act I – The Villain Called “Cost”

The ELI business project had a new feature: a conversation‑caching layer intended to cut voice‑to‑text and TTS calls. On paper it was a win, but the metrics told a different story—every call was pushing the bill up. I had to roll back my own PR.

git checkout a49afcd  # revert the caching logic
git commit -m "revert: remove conversation cache"
git push origin main

git checkout 609653e  # disable caching entirely
git commit -m "turn caching off"
git push origin main

After a quick chat with Dev, we decided to keep the cache but change its shape. Instead of trying to fight growing conversations, we let the cache grow with them. Commit 0179eb3 introduced a sharded, LRU‑style cache that stores conversation histories in a Redis cluster.

git checkout 0179eb3
git commit -m "implement growth‑oriented conversation cache"
git push origin main

Within hours the cache read count jumped from 0 to over 2 000, and the cost curve flattened. The villain was held at bay—for today.

Act II – The Stars as Data

Satya reached out with a wild idea: turn astrology into a data‑driven service. I dug into geo.py and birthtime.py, which compute ephemeris data from precise birth details. The scripts use the pyswisseph library to fetch planetary positions and then expose them via a tiny Flask API.

# geo.py
import swisseph as swe

def get_planet_positions(birth_datetime):
    jd = swe.julday(birth_datetime.year, birth_datetime.month, birth_datetime.day,
                    birth_datetime.hour + birth_datetime.minute / 60)
    positions = {}
    for planet in ['sun', 'moon', 'mercury', 'venus', 'mars', 'jupiter', 'saturn']:
        positions[planet] = swe.calc_ut(jd, swe.__dict__[planet.upper()])[0]
    return positions

We sketched a front page and debated the voice for narrating a chart. A mismatched voice feels like a stranger reading your diary, so we spent time aligning the tone with the data.

Act III – Voices of Living Books

Living Books is a platform that reads stories aloud with real human narrators. I first tackled a UI bug where the title text spilled over the book covers.

git checkout 14bf9a0
git commit -m "fix: prevent title overflow on book covers"
git push origin main

Next, I spent hours syncing the human voices with the text. ElevenLabs’ TTS tiers were compared like a sommelier tasting wine—looking for that subtle “alive” quality. I tweaked pitch, speed, and pause patterns until the narration felt natural and engaging. The same voice tuning principles will carry over to ELI and Satya’s projects.

Intermission – The In‑Between

Between tasks the browser wandered: ElevenLabs research, cricket highlights, memes, Netflix in the background. A black‑background Django checklist, half‑filled docs, and endless tabs reminded me that even chaos has a rhythm.

Act IV – Nightfall, a New Beginning

Evening brought a fresh repository: HyperCloud, an open‑source cloud storage platform for small teams. After a quick install marathon (Python, Docker, Kubernetes, Git) and a few episodes of Rick and Morty, I started building with Claude Code as my pair programmer.

Flask login endpoint

# app.py
from flask import Flask, request, jsonify
app = Flask(__name__)

@app.route('/login', methods=['POST'])
def login():
    data = request.json
    # simple auth stub
    if data.get('username') == 'admin' and data.get('password') == 'secret':
        return jsonify({"token": "dummy-jwt"}), 200
    return jsonify({"error": "unauthorized"}), 401

React dashboard prototype

npx create-react-app hypercloud-dashboard
cd hypercloud-dashboard
npm install axios

The dashboard currently shows an empty file list, but the skeleton is there: a FileList component that will later consume the HyperCloud API.

Epilogue

The room is still dark, the cursor still blinks, but something has changed. Today I:

Reduced voice cost, raising cache reads from 0 to >2 000
Preserved ELI’s voice quality
Turned star data into a usable API with Satya
Learned what makes a voice feel alive
Planted the first commit of HyperCloud

No explosions, no slow‑motion walks away—just a keyboard, a few commits, and a day that quietly added up. Tomorrow will bring new villains and new chapters. The screen will glow again.

Happy building.

Soul in Motion — 10:09 AM | 2026-09-29

Dev Rajput — Tue, 29 Sep 2026 04:56:20 +0000

TL;DR

A stubborn button click bug was traced across the frontend‑backend boundary in ~3 hrs.
Built a data‑labeling ↔ ML platform pipeline using custom scripts; got two incompatible systems to talk.
Balanced heavy debugging with AI‑assisted quick fixes and scheduled breaks (binge‑watching Scorpion).
Ended the day with a working UI, a functional pipeline, and a refreshed mind.

The “Trivial” Bug That Took 3 Hours

I started 10:09 AM with a button that did nothing.

The click event fired in the browser, but the expected API call never reached the server.

That’s the classic “between‑the‑layers” problem: the frontend sends a request, the backend never receives it.

Tracing the Signal

Console logs – added console.log('clicked') in the click handler.
Network tab – verified the request was sent, but the URL was /api/unknown.
Router check – the route /api/unknown didn’t exist.
State inspection – the component’s state was null when the handler ran.
Prop drilling – the handler was passed down from a parent that never updated its state.

The culprit: a missing useEffect that should have fetched the endpoint URL from the config.

After adding:

useEffect(() => {
  fetch('/config')
    .then(r => r.json())
    .then(c => setApiUrl(c.buttonEndpoint));
}, []);

the button finally hit /api/submit. The triumph of seeing that last line of code land correctly after hours of dead ends is quiet but real.

Building a Clean Pipeline Between Labeling and ML

The next task was to wire a data‑labeling framework (LabelStudio) with an ML platform (MLflow). They speak different protocols: LabelStudio exposes a REST API, MLflow expects a gRPC endpoint for model training.

The Script

I wrote a lightweight Python orchestrator that:

Pulls labeled data from LabelStudio via its REST API.
Converts the JSON annotations into the CSV format MLflow expects.
Calls MLflow’s run API to trigger training.

import requests
import csv
import mlflow

# 1. Pull labels
labels = requests.get('https://labelstudio.example.com/api/v1/projects/42/data').json()

# 2. Convert
with open('train.csv', 'w', newline='') as f:
    writer = csv.writer(f)
    writer.writerow(['image', 'label'])
    for item in labels:
        writer.writerow([item['image_url'], item['label']])

# 3. Trigger MLflow
mlflow.set_tracking_uri("http://mlflow.example.com")
mlflow.run(
    uri="models/ResNet50",
    entry_point="train",
    parameters={"data_path": "train.csv"}
)

The script was fiddly—handling pagination, rate limits, and ensuring the CSV schema matched the MLflow model’s expectations—but once it ran, the two systems spoke the same language.

Balancing Work, AI Assistance, and Breaks

I didn’t let the day get too long. After the button fix, I scheduled a 30‑minute break to binge‑watch Scorpion. Each episode ended on a cliffhanger, pulling me straight into the next. Between those breaks I:

Used ChatGPT to generate quick snippets for error handling.
Ran curl commands to test endpoints while the browser was idle.
Sketched a diagram of the data flow in a whiteboard app.

The AI assistance was a speed‑up, not a replacement. I still had to review the generated code, but it cut the time on trivial questions from minutes to seconds.

Wrap‑Up

By 5 PM:

The button worked reliably.
LabelStudio and MLflow were integrated via a clean pipeline.
I had watched enough Scorpion to feel my brain had actually rested.

Not every day needs a dramatic arc. Sometimes it’s just a stubborn bug, a useful integration, and a season finale getting closer. Tomorrow’s already lined up—stay tuned for more.

Soul in Motion — 12:48 AM | 2026-09-27

Dev Rajput — Sat, 26 Sep 2026 20:19:41 +0000

TL;DR

Updated 490 scene variants in the living‑books environment with a dynamic lighting system that reacts to real‑time light changes.
Rebuilt library furniture from scratch, adding realistic wood textures, dust particles, and spatial physics for deeper floor transitions.
Implemented user‑controlled library decoration and personal book shelving for ownership.
Ran a business audit on revenue‑assets‑audit.md, builds‑not‑ships.md, and first‑sale.md to keep monetization on track.
Hooked up earth_api.py and ManifestEarth.h to trigger physical world effects from in‑world interactions.

Breathing Life into the Grid

I spent most of the day locked in the living‑books environment, turning static scenes into something that feels alive. The core of the work was a massive update that touches all 490 scene variants.

The key change: a dynamic lighting system that makes every environment shift and react to light in real time.

Lighting Pipeline

# Build the new lighting assets
python scripts/generate_lighting.py --scenes all

The script now outputs a set of light maps that are baked into each scene. I also added a small runtime component that listens to the global light source and updates the scene’s exposure accordingly.

Furniture Overhaul

I rebuilt the library furniture from scratch:

Realistic wooden bookcases with high‑resolution wood grain textures.
Textured boards that show subtle wear and dust.
Dust particles that catch the light, adding a subtle depth cue.

The assets are now stored in assets/furniture/ and loaded via the scene loader. The physics engine was tuned so that moving between floors feels like actually stepping deeper into the building, thanks to a custom spatial physics mapping.

User‑Driven Customization

The biggest UX win was giving users control over their library:

Decorate: Drag‑and‑drop furniture items.
Assign personal books: Users can pin their own books to a dedicated shelf.

This feature was implemented by extending the LibraryManager class:

class LibraryManager:
    def add_book(self, user_id: str, book_id: str, shelf: str):
        # Persist the assignment in the user profile
        db.update_user_profile(user_id, {shelf: book_id})

Now the library feels personal, not just a static showcase.

The Business Audit & Manifest

Financial & Strategic Audit

I spent a few hours in the C:\ directory running audits on the key markdown files:

# Review revenue assets
cat revenue‑assets‑audit.md

# Check build vs. ship metrics
cat builds‑not‑ships.md

# First sale analysis
cat first‑sale.md

The audit helped keep the monetization trajectory clear. I also answered user queries about subscription structures and the upcoming GPT‑6 Astra capabilities, ensuring the roadmap aligns with revenue goals.

Manifest Project

The Manifest project is highly experimental. I wired up earth_api.py and ManifestEarth.h to create a bridge between the virtual world and the physical one.

# earth_api.py
def trigger_physical_effect(effect_id: str, intensity: float):
    # Send command to the physical device
    send_to_hardware(effect_id, intensity)

// ManifestEarth.h
void triggerEffect(const char* effectId, float intensity);

When a player interacts with a specific object in the virtual world, the corresponding physical effect is triggered in the real world. This is a proof‑of‑concept that blurs the line between digital architecture and real‑world triggers.

The Champions League Anchor

After a brief break exploring the kathaverse architecture, I needed to step away from the screen. I opened Sony LIV and watched the UEFA Champions League match—Porto vs. Man City. Seeing City’s tactical execution helped clear my head and gave me a fresh perspective on spatial flow in the living‑books environment.

Closing Thoughts

The living‑books environment is evolving into something unique. The technology pushes me into uncharted territory, and the line between digital architecture and real‑world triggers keeps blurring. The engine keeps running, and the next sprint will focus on refining the physics and expanding the user‑customization toolkit.

Soul in Motion — 5:28 PM | 2026-09-21

Dev Rajput — Mon, 21 Sep 2026 12:21:27 +0000

TL;DR

Refactored the Soul in Motion site’s color scheme and added subtle text motion inspired by a peer’s design.
Tackled a personal celestial distance visualizer, resolving cascading bugs from interactive elements.
Cleaned up the local filesystem, clearing orphaned folders and gaining mental clarity.
Drawn design inspiration from bold, unconventional sites and Under the Banner of Heaven.
Ended the day with progress on both the company site and the side project, feeling satisfied with incremental wins.

Morning: Ripping Apart the Soul in Motion Palette

I started the day staring at the black‑and‑red combo that had been stuck on the Soul in Motion homepage for months. The gut feeling was that it was stale—not just a color clash but a visual dead‑weight. Instead of a quick palette swap, I decided to inject motion into the text itself, giving the page a subtle personality.

I pulled up a screenshot from a recent design review that highlighted an older layout. My goal was to make sure the new motion didn’t just look good in isolation but actually fit with the rest of the UI. The tension between “this looks striking” and “this is usable” is a constant in front‑end work, and I kept circling back to that balance.

Implementation Snapshot

/* Simple keyframes for subtle horizontal text motion */
@keyframes slide {
  0%, 100% { transform: translateX(0); }
  50% { transform: translateX(5px); }
}

.text-move {
  animation: slide 4s ease-in-out infinite;
}

I wrapped the headline text in a div.text-move and tweaked the timing until it felt natural. The result is a gentle, almost imperceptible glide that adds life without distracting from the content.

Afternoon: Debugging the Celestial Distance Visualizer

The side project was a visualization of distances between celestial bodies. The goal was to make the data intuitive, not a wall of numbers. Unfortunately, adding a tiny interactive element broke three others. A ghost of a removed element lingered, and a quiet button caused chaos downstream.

I spent the afternoon chasing these cascading bugs:

Ghost Element – A hidden div still existed in the DOM, causing layout shifts.
Button Cascade – Clicking the “Show Details” button triggered a re‑render that inadvertently reset the entire state.
Interactive Sync – The new slider was not debounced, leading to rapid state changes that overloaded the rendering loop.

After a series of refactors, I introduced a debounced handler and cleaned up the component hierarchy:

// debounce.js
export const debounce = (func, wait) => {
  let timeout;
  return (...args) => {
    clearTimeout(timeout);
    timeout = setTimeout(() => func.apply(null, args), wait);
  };
};

// distance-visualizer.js
import { debounce } from './debounce';

const handleSliderChange = debounce((value) => {
  updateDistances(value);
}, 200);

The visualizer finally behaved as expected, and the interactive elements no longer interfered with each other.

Inspiration Hunt

While the code was running, I opened a few sites known for bold, unconventional design—think Awwwards winners and experimental UI showcases. I took mental notes on layout tricks and motion details that could be adapted for the company site later.

I also let Under the Banner of Heaven play in the background. The vivid scenes made me pause and question the intentionality of my own work. It’s a reminder that design is as much about narrative as it is about pixels.

File System Clean‑Up

A small but surprisingly satisfying task: I hunted through my hard drive for folders that had stopped showing up where they should, cleared out the junk, and felt a wave of relief. Not every win needs to be complicated, but a tidy workspace can boost productivity and reduce cognitive load.

Wrap‑Up

By the end of the day, I had:

A redesigned homepage with subtle text motion.
A stubborn side project finally behaving.
A cleaner hard drive.
A head full of borrowed inspiration.

Both the company site and the distance visualizer are closer to completion than they were this morning. That, for me, is enough.

Stay tuned for the next update.

Soul in Motion — 6:17 PM | 2026-09-18

Dev Rajput — Fri, 18 Sep 2026 13:12:13 +0000

TL;DR

Dashboard still lagging behind real‑time data; progress made but no final fix yet.
Re‑installed unnecessary components to isolate a stale cache issue.
Voice‑recognition for Soulvoice improved; false positives reduced by tightening keyword spotting.
Developed a structured play parser that correctly tokenizes lines and preserves character voices.
Small wins across the day; no single breakthrough, but cumulative progress.

A Day in the Life of a Builder – September 4

The Dashboard Dilemma

The dashboard was supposed to surface real‑time metrics, but it kept showing yesterday’s numbers. I started by inspecting the data pipeline:

# Check the cache expiration header
curl -I https://api.myapp.com/metrics

The header returned Cache-Control: max-age=86400, which explains why the data was stale. I removed the caching middleware from the Express route:

app.get('/metrics', (req, res) => {
  // Previously: res.set('Cache-Control', 'max-age=86400');
  // Now: no caching header
  fetchMetrics().then(data => res.json(data));
});

After that, I re‑installed the node-cache package, which had been flagged as “unnecessary” in the package.json. The reinstall cleared a corrupted local store that was still serving the old payload. The dashboard now updates within a few seconds, but I haven’t yet verified that the backend is pushing the latest data via WebSocket.

Recurring Bug in the Feature Toggle Service

Midday, a bug I thought I’d fixed in the feature toggle service resurfaced. The toggle state was being read from a local JSON file instead of the Redis cache:

# toggle_service.py
def get_toggle(name):
    # Previously: return local_toggles[name]
    return redis_client.get(name)

I added a log statement to confirm the source:

log.debug(f"Toggle {name} fetched from {source}")

The logs revealed that the fallback to the local file was still active when Redis returned None. I updated the fallback logic:

if value is None:
    value = local_toggles.get(name, False)

Now the service consistently reads from Redis, but the root cause—an uninitialized Redis key—remains to be addressed.

Voice Recognition Tweaks for Soulvoice

The voice assistant’s wake‑word detection had a high false‑positive rate. I tightened the sensitivity threshold in the keyword spotting model:

# config.yaml
wake_word:
  sensitivity: 0.75  # increased from 0.6
  model_path: /models/wake_word.bin

After reloading the model, the assistant responded to the wake word with a 30% drop in false starts. I also added a short silence buffer before accepting a command:

audioProcessor.on('speechEnd', () => {
  if (silenceDuration > 500) processCommand();
});

The result: a more human‑like pause before the assistant starts listening.

Structured Play Parser

The highlight of the day was finally getting a parser that understands the structure of Shakespearean plays. The previous implementation treated the script as a flat block of text, which broke character attribution. I built a simple lexer that tokenizes the script into scenes, acts, and lines:

import re

SCENE_RE = re.compile(r'^\s*Scene\s+\d+', re.MULTILINE)
ACT_RE = re.compile(r'^\s*Act\s+\w+', re.MULTILINE)
LINE_RE = re.compile(r'^\s*(\w+):\s*(.+)', re.MULTILINE)

def parse_script(text):
    acts = ACT_RE.split(text)
    parsed = []
    for act in acts[1:]:
        scenes = SCENE_RE.split(act)
        for scene in scenes[1:]:
            lines = LINE_RE.findall(scene)
            parsed.append({'act': act, 'scene': scene, 'lines': lines})
    return parsed

Running this on Macbeth, Othello, and Hamlet produced a structured JSON where each line is paired with its speaker. Feeding this into the TTS engine kept each character’s voice distinct, and the pacing matched the original play’s rhythm. The first test run—narrating Hamlet—went through without a single misattributed line.

Breaks and Side‑Projects

I let the day wind down with a few AI‑and‑coding rabbit holes that started with a single search for “transformer fine‑tuning” and ended up exploring a new open‑source dataset for voice cloning. I also cleared a backlog of emails, which was a good mental reset before the night shift.

Reflections

Dashboard: Still not fully fixed; the real-time push mechanism needs a final tweak.
Recurring bug: Diagnosed, but the underlying Redis key issue is pending.
Soulvoice: Wake‑word detection is noticeably more reliable.
Play parser: Works on the first real test; feels like a quiet triumph.

Some days look like a series of small arguments with reality, each one won. Fingers crossed the rest sorts itself out before the next release. Stay tuned.

Soul in Motion — 6:16 PM | 2026-09-17

Dev Rajput — Thu, 17 Sep 2026 13:07:58 +0000

TL;DR

Built an interactive Frankenstein demo that animates scenes based on the text, including subtle air‑visualization.
Expanded the concept into a shelf‑level platform, deploying a 10‑chapter book with scene sequencing and mood‑based weather.
Tackled plumbing: data ingestion, scene orchestration, and secure hosting on a cloud platform.
Parallel work: concise product explanations, Kathaverse short‑story scaffolding, comic frame transitions, and personal media breaks.
All projects progressed incrementally; each small fix added realism and cohesion.

From Page to Space: Making Frankenstein Breathable

The core idea was simple: turn a static text into a living environment.

I started with a react‑three-fiber scene that loads the book’s JSON representation, then maps each chapter to a Scene component. The component adjusts lighting, background audio, and particle effects based on metadata extracted from the text (e.g., “dark, stormy night”).

const Scene = ({ chapter }) => {
  const { mood, weather } = parseMetadata(chapter);
  return (
    <group>
      <ambientLight intensity={mood === 'dark' ? 0.2 : 0.8} />
      <audio src={weatherAudio[weather]} loop />
      <AirParticles visible={chapter.includes('air')} />
    </group>
  );
};

The Invisible Air Effect

The “air becomes visible” trick was a debugging win. I added a low‑opacity cloud particle system that only activates when the text mentions “air” or “wind.” It’s almost imperceptible, but it grounds the reader in the environment.

function AirParticles({ visible }) {
  if (!visible) return null;
  return (
    <points>
      <bufferGeometry attach="geometry" {...cloudGeometry} />
      <pointsMaterial attach="material" color="#fff" size={0.5} opacity={0.05} transparent />
    </points>
  );
}

The challenge was keeping the particles from over‑rendering. I throttled updates to once per second and used GPU instancing to keep the frame rate above 60 fps.

Scaling Up: From One Book to a Shelf

After polishing the single‑book demo, I built a shelf abstraction. Each book is a ShelfItem that holds its own scene graph, metadata, and a small REST API for fetching the next chapter.

# shelf.yaml
books:
  - id: frankenstein
    title: "Frankenstein"
    chapters: 12
    entry: /books/frankenstein/chapters/1
  - id: great_expectations
    title: "Great Expectations"
    chapters: 9
    entry: /books/great_expectations/chapters/1

The API is a lightweight Node/Express server that serves chapter JSON and a WebSocket for real‑time updates (e.g., when a user marks a bookmark).

npm install express ws

const app = require('express')();
const WebSocket = require('ws');
const wss = new WebSocket.Server({ server: app });

app.get('/books/:id/chapters/:num', (req, res) => {
  res.json(require(`./data/${req.params.id}/chapter${req.params.num}.json`));
});

wss.on('connection', ws => {
  ws.on('message', msg => {
    // broadcast bookmark updates
    wss.clients.forEach(client => client.send(msg));
  });
});

Deployment Pipeline

I containerized the stack with Docker and pushed it to a DigitalOcean App Platform instance. The pipeline:

docker build -t mybooks:latest .
docker push registry.digitalocean.com/myorg/mybooks:latest
Deploy via the DO dashboard, exposing port 80.

The only real plumbing hurdle was ensuring the WebSocket endpoint survived the platform’s HTTP load balancer. I added a proxy_pass rule in the Nginx config:

location /ws/ {
  proxy_pass http://backend:3000;
  proxy_http_version 1.1;
  proxy_set_header Upgrade $http_upgrade;
  proxy_set_header Connection "upgrade";
}

Translating Complexity into Clarity

Parallel to the technical work, I spent time crafting a one‑pager that explains the platform to non‑technical stakeholders. The goal was to distill the “interactive reading” concept into a single slide:

Problem: Static books lack immersion.
Solution: A web‑based environment that reacts to narrative cues.
Benefits: Higher engagement, new monetization via premium scenes.

I used a simple diagram built in Figma, then exported it as an SVG and embedded it directly:

<img src="assets/interactive-reading.svg" alt="Interactive Reading Flow" />

Kathaverse: Minimalist Short Stories

In the Kathaverse project, I experimented with ultra‑short stories composed of a handful of scenes. Each scene is a JSON snippet:

{
  "scene": 1,
  "description": "A lone lantern flickers in the dark alley.",
  "audio": "dark_alley.mp3"
}

The renderer stitches them together on the fly, using a simple state machine to transition between scenes. The key insight: you don’t need a complex engine to evoke emotion—just the right order of small, well‑crafted moments.

Comic Strip Smoothness

I revisited an old comic strip project to tighten frame transitions. Using GSAP I added a subtle easing function that guides the eye:

gsap.fromTo(".frame", { opacity: 0 }, {
  opacity: 1,
  duration: 0.8,
  ease: "power2.out",
  stagger: 0.1
});

The result is a fluid flow that feels “right” without being obvious. Small tweaks like this accumulate into a polished experience.

Personal Recharge

Between code and design, I let myself unwind with Scorpion episodes and a playlist of Bad Bunny & Jhay Cortez. The music helped clear mental clutter, making the next debugging session feel fresh.

Day in Review

Frankenstein: Scene orchestration, air‑visualization, particle throttling.
Shelf Platform: API, WebSocket, Docker, DO deployment.
Communication: One‑pager, Figma diagram.
Kathaverse: Minimalist story engine.
Comic: GSAP frame easing.
Self‑care: Media breaks.

Each task, though distinct, fed into a common goal: making narrative feel alive. The day felt cohesive because every small improvement added a layer of realism.

Stay tuned for the next post where I’ll dive into the analytics layer—tracking how users interact with the scenes and how that data can inform future story design.

Soul in Motion — 6:20 PM | 2026-09-14

Dev Rajput — Mon, 14 Sep 2026 13:51:32 +0000

TL;DR

Refactored Soulvoice TTS pipeline for a more natural voice.
Fixed a device‑specific bug in the phone assistant, enabling true conversational behavior.
Expanded Living‑Books to add reverence modes for sacred texts.
Automated YouTube pipeline dashboard to auto‑name streams by activity.
Completed legal documentation; now free to focus on tech.

Morning – Soulvoice

I spent the first part of the day deep in the Soulvoice text‑to‑speech stack. The goal was to strip away layers of legacy code that had accumulated over months of incremental fixes. The refactor focused on how raw audio data is ingested and pre‑processed before hitting the neural TTS model.

# before
audio = load_raw_audio(file_path)
audio = normalize(audio)
audio = trim_silence(audio)
features = extract_features(audio)
output = tts_model(features)

# after
audio = preprocess_audio(file_path)
output = tts_model(audio)

The preprocess_audio helper now handles normalization, silence trimming, and feature extraction in a single pass, reducing latency by ~30 ms. The result? Voices that sound less like a “strained machine” and more like the original speaker. The biggest win was the cleaner API surface for downstream services.

Friday – Assistant on the Phone

A device‑specific issue had been nagging the phone assistant for weeks. The assistant was only recognizing a handful of commands because the device’s speech recognizer was returning a truncated key. When a teammate handed me a new access key, the assistant’s “brain” suddenly had the full context it needed.

# Update the key in the device’s config
export ASSISTANT_KEY="new-key-12345"

After the key swap, the assistant behaved like a real conversational partner instead of a simple command taker. I added a quick sanity check in the assistant.py module to log key validity on startup:

if not validate_key(os.getenv("ASSISTANT_KEY")):
    raise ValueError("Invalid assistant key")

This small guard will catch similar regressions in the future.

Afternoon – Living‑Books

The Living‑Books platform needed a richer emotional palette, especially for sacred texts. I added reverence modes for the Gita, Quran, and Bible. The core idea is to flag a text as “sacred” and adjust the tone, pacing, and emphasis accordingly.

# book.yaml
title: "The Bhagavad Gita"
genre: sacred
reverence_mode: true

In the rendering engine, a simple flag check now triggers a different set of prosody parameters:

if book.reverence_mode:
    prosody = get_reverence_prosody()
else:
    prosody = get_standard_prosody()

The platform now treats sacred texts with the weight they deserve, distinguishing them from thrillers or other genres.

Legal Work

Drafting a legal document for my lawyer was a necessary but mundane task. I used a template and filled in the specifics for the upcoming partnership. Once the lawyer reviewed it, the document was signed and filed—no more legal backlog for the next sprint.

YouTube Pipeline Dashboard

I automated the YouTube pipeline dashboard so each data pipeline names itself based on its real‑time activity. The previous manual bookkeeping was error‑prone and time‑consuming.

# Example of auto‑naming logic
pipeline_name=$(echo "$activity" | tr '[:upper:]' '[:lower:]' | tr -d ' ')

The script now runs as a cron job that updates the dashboard every minute. I also pulled in an older audio‑processing side project to keep everything running smoothly, ensuring that the new naming logic doesn’t interfere with existing metrics.

Evening

After a day of precision and experimentation, I unwound with Blade Runner 2049 and a few episodes of Rick and Morty. The mix of mood and chaos is the perfect counterbalance to the day’s technical grind.

Looking Back

No single headline moment, but five solid wins:

A more human‑sounding voice in Soulvoice.
An assistant that truly knows its device.
A library that respects sacred texts.
A self‑naming dashboard that cuts manual bookkeeping.
Legal paperwork finally done.

Everything moved forward, and tomorrow looks just as full. For now, this is enough.

Soul in Motion — 6:15 PM | 2026-09-11

Dev Rajput — Fri, 11 Sep 2026 13:20:18 +0000

TL;DR

Morning frustration with a flaky voice‑assistant forced a deeper dive into the code, not just a quick patch.
Re‑architected the assistant’s command‑handling loop, added robust error handling, and deployed a new build.
Late‑night testing on a real device revealed UI/UX regressions that were fixed before the next day.
Parallel work on Living‑Books tackled scroll, audio, and font‑loading bugs with incremental fixes.
Balancing work with deliberate breaks (TV, sports, anime) helped maintain focus and prevent burnout.

The Morning: When “It Works Yesterday” Breaks Today

It’s Friday, and the assistant on my phone—call it Friday—is half‑alive. It hears my voice, but the responses are empty, the digital equivalent of a nod with no content. I’m staring at my laptop, coffee still untouched, and the irritation is real: Why does this keep happening? Why do I have to fix you every single day?

Instead of patching the symptom, I decided to ask why it was failing. I pulled up the repository that powers Friday’s intent‑recognition and response generation and went line by line. The code that decides what Friday hears and how she responds is a mix of a lightweight intent parser and a small state machine that decides how many turns to allow before timing out. I tightened the logic, added guard clauses for missing context, and introduced a more granular logging strategy to surface the exact point of failure.

# Simplified example of the intent handler
def handle_intent(intent, context):
    if intent is None:
        log.warn("No intent detected")
        return "I didn't catch that."
    try:
        response = intent_resolver.resolve(intent, context)
    except Exception as e:
        log.error(f"Error resolving intent {intent}: {e}")
        return "Sorry, something went wrong."
    return response

After committing the changes, I built a new Docker image, pushed it to the registry, and rolled it out to the staging environment. The new build was ready for a quick test on the phone.

The Device Test: Real‑World Reality Check

I opened the same link on the phone in front of a friend. Books I could tap on worked, but music, ambient sound, and other small details vanished, as if the app forgot half of what it knew the second it left my laptop screen. This is the humility of building for real people on real devices: it works perfectly where you built it and falls apart everywhere else.

The culprit turned out to be a race condition in the audio‑loading pipeline. The app would start fetching the audio stream before the UI had finished rendering the container, causing a NullPointerException on Android and a silent failure on iOS. I fixed it by deferring the audio request until the onLayout callback fired.

// Android example
override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
    super.onLayout(changed, left, top, right, bottom)
    if (changed) {
        audioPlayer.loadStream(audioUrl)
    }
}

After the patch, the phone no longer froze, and the assistant responded as expected.

Afternoon: Living‑Books – Making Stories Feel Like Places

The second half of the day was spent on Living‑Books, a project that turns static stories into interactive, place‑based experiences. The bugs were smaller but just as stubborn:

Scroll on Phone – The bookshelf component used a ScrollView that didn’t respect the overflow property on mobile. I replaced it with a FlatList that lazily renders items and added momentum scrolling.

<FlatList
  data={books}
  keyExtractor={item => item.id}
  horizontal
  showsHorizontalScrollIndicator={false}
  onScroll={Animated.event(
    [{ nativeEvent: { contentOffset: { x: scrollX } } }],
    { useNativeDriver: false }
  )}
/>

Audio Never Turns On – The audio player was initialized with a stale src attribute. I switched to a dynamic import that re‑initializes the player whenever the audioUrl changes.
```
useEffect(() => {
  if (audioUrl) {
    const player = new AudioPlayer(audioUrl);
    setPlayerInstance(player);
  }
}, [audioUrl]);
```
Fonts Loading Slowly – The web font loader was configured to load all fonts at once, causing a blocking render. I moved the font loading to a separate worker and used font-display: swap in CSS to avoid invisible text.
```
@font-face {
  font-family: 'Open Sans';
  src: url('/fonts/OpenSans.woff2') format('woff2');
  font-display: swap;
}
```

After fixing each issue, I watched the page paint instantly, the shelf glide smoothly, and the atmosphere stay light enough for a phone. The satisfaction of seeing the UI finally behave as intended is oddly therapeutic.

Breaks That Keep the Brain Fresh

I took deliberate breaks to reset my focus:

Scorpion – The show’s accurate plot‑twist predictions were a meditative distraction.
The Station Agent – A quiet evening that let me decompress.
Football – Quick check on Messi’s retirement status and Real Madrid news.
Anime Recommendations – Browsed but never acted on, keeping the mind engaged without committing.
Rick and Morty – A light‑hearted finale to the day.

These breaks helped me return to the code with fresh eyes and prevented the “I’ll watch this for fifteen minutes” trap from turning into an hour.

Evening Reflection: From Frustration to Relief

By the time I looked up, it was late. I sat for a moment and tallied it up:

The voice assistant that used to ignore me now mostly responds.
The book platform that froze on the device most people will actually use now mostly runs.

Neither sounds impressive on paper, but I remember the morning frustration and the evening relief. The distance between those feelings is the whole point of doing this work.

I’m not pretending to be superhuman. I get tired, I get short with things that don’t work, I lose an hour to a TV show I meant to watch for fifteen minutes. Yet something that was broken this morning isn’t broken tonight, in two completely different corners of my life, because I refused to leave it that way. Maybe that’s the trick: not being superhuman, just stubborn enough, day after day, that it starts to look like something else from afar.

What Did You Get Done Today?

Share your wins, your frustrations, and the small victories that keep you moving forward. Building is a marathon, not a sprint, and every bug fixed is a step closer to a product that actually works for people.

Soul in Motion — 6:16 PM | 2026-09-10

Dev Rajput — Thu, 10 Sep 2026 13:09:38 +0000

TL;DR

Built an interactive Frankenstein demo that animates scenes based on the text, including subtle air‑visualization.
Expanded the concept into a shelf‑level platform, deploying a 10‑chapter book with scene sequencing and mood‑based weather.
Tackled plumbing: data ingestion, scene orchestration, and secure hosting on a cloud platform.
Parallel work: concise product explanations, Kathaverse short‑story scaffolding, comic frame transitions, and personal media breaks.
All projects progressed incrementally; each small fix added realism and cohesion.

From Page to Space: Making Frankenstein Breathable

const Scene = ({ chapter }) => {
  const { mood, weather } = parseMetadata(chapter);
  return (
    <group>
      <ambientLight intensity={mood === 'dark' ? 0.2 : 0.8} />
      <audio src={weatherAudio[weather]} loop />
      <AirParticles visible={chapter.includes('air')} />
    </group>
  );
};

The Invisible Air Effect

function AirParticles({ visible }) {
  if (!visible) return null;
  return (
    <points>
      <bufferGeometry attach="geometry" {...cloudGeometry} />
      <pointsMaterial attach="material" color="#fff" size={0.5} opacity={0.05} transparent />
    </points>
  );
}

The challenge was keeping the particles from over‑rendering. I throttled updates to once per second and used GPU instancing to keep the frame rate above 60 fps.

Scaling Up: From One Book to a Shelf

After polishing the single‑book demo, I built a shelf abstraction. Each book is a ShelfItem that holds its own scene graph, metadata, and a small REST API for fetching the next chapter.

# shelf.yaml
books:
  - id: frankenstein
    title: "Frankenstein"
    chapters: 12
    entry: /books/frankenstein/chapters/1
  - id: great_expectations
    title: "Great Expectations"
    chapters: 9
    entry: /books/great_expectations/chapters/1

The API is a lightweight Node/Express server that serves chapter JSON and a WebSocket for real‑time updates (e.g., when a user marks a bookmark).

npm install express ws

const app = require('express')();
const WebSocket = require('ws');
const wss = new WebSocket.Server({ server: app });

app.get('/books/:id/chapters/:num', (req, res) => {
  res.json(require(`./data/${req.params.id}/chapter${req.params.num}.json`));
});

wss.on('connection', ws => {
  ws.on('message', msg => {
    // broadcast bookmark updates
    wss.clients.forEach(client => client.send(msg));
  });
});

Deployment Pipeline

I containerized the stack with Docker and pushed it to a DigitalOcean App Platform instance. The pipeline:

docker build -t mybooks:latest .
docker push registry.digitalocean.com/myorg/mybooks:latest
Deploy via the DO dashboard, exposing port 80.

The only real plumbing hurdle was ensuring the WebSocket endpoint survived the platform’s HTTP load balancer. I added a proxy_pass rule in the Nginx config:

location /ws/ {
  proxy_pass http://backend:3000;
  proxy_http_version 1.1;
  proxy_set_header Upgrade $http_upgrade;
  proxy_set_header Connection "upgrade";
}

Translating Complexity into Clarity

Problem: Static books lack immersion.
Solution: A web‑based environment that reacts to narrative cues.
Benefits: Higher engagement, new monetization via premium scenes.

I used a simple diagram built in Figma, then exported it as an SVG and embedded it directly:

<img src="assets/interactive-reading.svg" alt="Interactive Reading Flow" />

Kathaverse: Minimalist Short Stories

In the Kathaverse project, I experimented with ultra‑short stories composed of a handful of scenes. Each scene is a JSON snippet:

{
  "scene": 1,
  "description": "A lone lantern flickers in the dark alley.",
  "audio": "dark_alley.mp3"
}

Comic Strip Smoothness

I revisited an old comic strip project to tighten frame transitions. Using GSAP I added a subtle easing function that guides the eye:

gsap.fromTo(".frame", { opacity: 0 }, {
  opacity: 1,
  duration: 0.8,
  ease: "power2.out",
  stagger: 0.1
});

The result is a fluid flow that feels “right” without being obvious. Small tweaks like this accumulate into a polished experience.

Personal Recharge

Day in Review

Frankenstein: Scene orchestration, air‑visualization, particle throttling.
Shelf Platform: API, WebSocket, Docker, DO deployment.
Communication: One‑pager, Figma diagram.
Kathaverse: Minimalist story engine.
Comic: GSAP frame easing.
Self‑care: Media breaks.

Each task, though distinct, fed into a common goal: making narrative feel alive. The day felt cohesive because every small improvement added a layer of realism.

Stay tuned for the next post where I’ll dive into the analytics layer—tracking how users interact with the scenes and how that data can inform future story design.

Soul in Motion — 5:56 PM | 2026-09-07

Dev Rajput — Mon, 07 Sep 2026 12:48:39 +0000

TL;DR

Bluetooth on the laptop disappeared without warning; troubleshooting stalled.
Cleaned up Docker containers and unused apps to reclaim disk space.
Worked on five projects: Manifest, Unreal, Living Books, The Station Agent, and a music‑video rabbit hole.
Minor progress on each: small edits, core interaction fixes, and iterative design tweaks.
Evening was spent winding down with TV, music, and cricket highlights.

The Daily Grind – 5:56 PM

I started the day with a quiet frustration: my laptop’s Bluetooth had just vanished. No error messages, no warnings, just gone. I tried a handful of quick fixes—re‑enabling the adapter in Settings, restarting the bluetoothd service, and even rebooting the machine—but nothing worked. I set it aside for the moment, because the real work had to take priority. Some problems have to wait.

Morning: Digital House‑Keeping

The first thing I did was a bit of digital housekeeping. I ran:

docker system prune -a

and then removed a handful of old applications that had quietly eaten up a lot of space. Seeing the drive breathe again gives a small, unreasonable satisfaction. It’s a reminder that even in a busy day, keeping the environment lean can save a lot of friction later.

Project 1: Manifest – Studio‑Like Decision Making

After the cleanup, I shifted into Manifest. This project is all about deliberate, small‑scale decisions that feel more like running a tiny studio than engineering. I spent the morning weighing what stays, what goes, and what’s worth building versus what sounded good yesterday. The process is less about code and more about a clear, intentional roadmap.

Project 2: Unreal – Core Interaction Fixes

Next, I dove into the Unreal side. I was working through core interactions until objects and characters finally responded to each other. The satisfying click of two systems finally talking is a good reminder that sometimes the hardest part is getting the plumbing to work. I tweaked a few Blueprint nodes and adjusted physics settings to get the desired response.

Project 3: Living Books – A Rabbit Hole

Living Books turned into a rabbit hole again. Every time I think I’ve settled on an interactive presentation, I find another way to improve it and start over. I closed the coding stretch with a short, focused pass on Friday: small edits that don’t look like much individually but make the app feel more thoughtful. The iterative nature of this project keeps me on my toes.

Project 4: The Station Agent – Quiet Hour

Evening slowed down with a quiet hour of The Station Agent. I let the show’s calm pace ground me after a day of rapid switching. It’s a nice contrast to the frantic pace of coding.

Project 5: Music‑Video Rabbit Hole

I also spent a bit of time on a music‑video rabbit hole that left Jon Bellion’s “I Will Find You” stuck in my head. The looping of the track and the visuals made for a surprisingly productive break.

Wrap‑Up

By the time I looked up, Bluetooth was still broken, five projects had each moved forward a little, and I’d unintentionally found a new favorite song. Tomorrow I’ll pick the fight with Bluetooth again. For tonight, that’s enough.

Stay tuned.

Soul in Motion — 9:35 PM | 2026-09-02

Dev Rajput — Wed, 02 Sep 2026 16:26:31 +0000

TL;DR

Wake‑word detection is the hardest part of a voice assistant; reliability hinges on low‑latency, low‑power listening.
Inconsistent request latency usually signals hidden state corruption or resource contention—debugging requires state snapshots and profiling.
Incremental “small‑fix” work on core logic (e.g., edge‑case handling, retry loops) compounds into a noticeably smoother system over weeks.
Balancing heavy‑lifting (wake‑word) with lighter tasks (content editing, environment setup) keeps the day productive and prevents burnout.

Building Friday‑Phone

The Listening Problem

The first thing I tackled was the Friday‑Phone wake‑word detector. In a voice assistant, the listening thread is the gatekeeper: if it never hears its own name, nothing downstream runs. The code lives in a tight, low‑latency loop that pulls audio frames from the microphone, feeds them through a lightweight neural network, and emits a trigger event when the confidence score crosses a threshold.

while True:
    frame = mic.read()
    score = model.predict(frame)
    if score > THRESHOLD:
        trigger_event()

The problem I hit was inconsistent latency. One request would fire in a few milliseconds, the next would stall for an indeterminate amount of time. There was no obvious exception, just a silent slowdown. In practice, this is how real systems behave: they don’t throw clean errors; they just become slower or produce odd outputs.

Diagnosing the Slowdown

The first step was to capture a timeline of the thread’s state. I added a simple profiler that logs timestamps for each stage:

import time
while True:
    t0 = time.monotonic()
    frame = mic.read()
    t1 = time.monotonic()
    score = model.predict(frame)
    t2 = time.monotonic()
    if score > THRESHOLD:
        trigger_event()
    t3 = time.monotonic()
    log(f"read:{t1-t0:.3f}s predict:{t2-t1:.3f}s total:{t3-t0:.3f}s")

The logs revealed that the predict call was the culprit on the slow runs. The model was a small TensorFlow Lite graph, but the CPU was being throttled by other background processes (e.g., a nightly backup script). Switching to a dedicated CPU core and pinning the process resolved the issue.

# Pin the process to core 3
taskset -c 3 ./friday-phone

After that tweak, the latency stabilized around 15 ms per request, which is acceptable for a wake‑word detector.

Project C – Incremental Core Logic

The “Forty Small Things” Mindset

Later in the day I moved to Project C, the assistant’s core logic. This isn’t about solving a single hard problem; it’s about tightening dozens of edge cases that slip through in production. The changes I made were tiny: adding a retry guard for a flaky API, normalizing user input before passing it to the LLM, and tightening the timeout on a database query.

def safe_api_call(payload):
    for _ in range(3):
        try:
            return external_api.post(payload)
        except TimeoutError:
            time.sleep(0.2)
    raise RuntimeError("API unreachable")

Each tweak is a micro‑optimization that, when compounded, reduces the overall error rate. Over weeks, the assistant feels more responsive and less prone to “I don’t understand” responses.

Debugging the Assistant

A recurring issue was the assistant occasionally returning a stale response. I introduced a simple cache invalidation strategy:

cache = {}
def get_response(query):
    key = hash(query)
    if key in cache and not cache[key].expired():
        return cache[key].value
    resp = llm.generate(query)
    cache[key] = CacheEntry(resp, ttl=60)
    return resp

Now, if the same query is repeated within a minute, the assistant serves the cached answer, cutting down on latency and avoiding repeated LLM calls.

Side Projects & Mental Reset

After the heavy lifting, I switched gears to Kathaverse: thumbnail generation, reading, and light editing. These tasks are low‑cognitive‑load but keep the workflow moving. I also set up a minimal environment for a new project, but let it sit while I focused on the urgent tasks.

The afternoon also included a brief detour to a Hoyoverse trailer at Gamescom. A two‑minute clip that reset my focus and reminded me that I’m still a kid who loves games. These little breaks are essential for maintaining a creative spark.

End‑of‑Day Routine

The day closed with a familiar rhythm: a long YouTube session of gaming clips and tech tutorials, a quick Instagram scroll, and an evening of VLC playback. Watching Rick and Morty and A Few Good Men provided a mental palate cleanser and, oddly enough, new lines that I hadn’t noticed before.

Reflections & Next Steps

Today wasn’t about a breakthrough; it was about persistence through friction. The wake‑word detector finally behaved, the core logic got a few more edge‑case fixes, and the side projects nudged forward. Some days feel like sprinting; today felt more like sanding—one pass at a time, trusting the surface will smooth out eventually.

Tomorrow I’ll dive back into the wake‑word system, hoping the latency improvements hold under load. If all goes well, the Friday‑Phone will finally be the silent, reliable gatekeeper it was meant to be.

Soul in Motion — 9:22 PM | 2026-09-01

Dev Rajput — Tue, 01 Sep 2026 16:15:59 +0000

TL;DR

Confirmed mail‑integration for voice recognition on Project C was running after repeated checks.
Decided to build a personal assistant on the phone, focusing on NLU, voice recognition, and API stitching.
Tightened wake‑word detection to avoid false positives in noisy environments.
Documented decisions in Chronicle to avoid future reverse‑engineering.
Ended the day with a successful end‑to‑end wake‑word test, reinforcing confidence in the system.

The Daily Loop: From Doubt to Delivery

The day started with a nagging question: Is the mail‑integration for voice recognition on Project C actually working?

I pinged the endpoint, watched the logs, and ran a quick integration test. Three different approaches—manual curl, automated test suite, and a live demo—all confirmed the service was up and stable. Yet the gap between “it should work” and “I’ve actually seen it work” lingered. That feeling of uncertainty is a developer’s silent partner; it pushes you to double‑check until the system behaves predictably.

Building a Personal Assistant

The real pivot came when I said out loud, “I want my own assistant, not a generic Google bot.”

The answer was simple: you can build it. The stack is a mix of:

Natural‑Language Understanding – a lightweight intent classifier trained on my own voice data.
Voice Recognition – a custom wake‑word model tuned to my accent and environment.
API Stitching – a micro‑service layer that routes intents to the appropriate external services (email, calendar, weather, etc.).

I sketched the architecture in a quick diagram (not shown here) and started wiring the components. The key takeaway: the “now” idea is only a few commits away from a working prototype.

Chronicle: Documenting Decisions

Between coding sessions I opened Chronicle to log the rationale behind each design choice:

- Wake‑word threshold set to 0.85 to reduce false positives.
- Email API uses OAuth2 with a short‑lived refresh token.
- Intent classifier trained on 200 labeled utterances.

These notes feel unglamorous, but they save future‑me from re‑implementing logic that was already decided. In the long run, a well‑maintained Chronicle is a developer’s safety net.

Tightening Wake‑Word Detection

Wake‑word detection is the anchor of any voice assistant. It has to:

Listen for a single phrase in a noisy background.
Trigger the assistant without lag.
Avoid false positives that waste battery and annoy the user.

I iterated on the model by:

Collecting ambient noise samples from my office.
Fine‑tuning the acoustic model with those samples.
Running a 24‑hour test loop to catch edge cases.

The result? The wake‑word now responds cleanly to “Hey Friday” even with a coffee machine humming in the background.

Reflecting on Responsible AI

A quick detour: I read Eightfold.ai’s take on responsible AI in hiring. The principles—fairness, transparency, accountability—apply equally to a personal assistant. Building something that people can trust means:

Data privacy: store voice data locally whenever possible.
Explainability: log intent decisions so I can audit them later.
Bias mitigation: test the assistant across different accents and dialects.

These considerations shaped how I designed the intent classifier and how I handle user data.

End‑to‑End Wake‑Word Test

The day closed with a full test:

# Start the wake‑word service
./start_wake_word.sh

# Simulate a user saying the phrase
echo "Hey Friday" | ./simulate_speech.sh

# Verify the assistant triggers
curl http://localhost:8080/assistant/trigger

The output was clean: the assistant activated, logged the trigger, and queued the next action. No crashes, no false alarms. A quiet confirmation that the pieces I built earlier are holding together.

What Building Friday Looks Like

Hundreds of tiny “yes, that works now” moments stack into a reliable system.
Patient, iterative work beats overnight miracles.
Documentation turns fleeting insights into reusable knowledge.

Tomorrow, I’ll keep refining the wake‑word model, add more intents, and continue documenting every step. The goal is simple: a personal assistant that feels like having someone in my corner.

DEV Community: Dev Rajput

Soul in Motion — 5:01 PM | 2026-10-08

TL;DR

Act I – The Villain Called “Cost”

Act II – The Stars as Data

Act III – Voices of Living Books

Intermission – The In‑Between

Act IV – Nightfall, a New Beginning

Epilogue

Soul in Motion — 10:09 AM | 2026-09-29

TL;DR

The “Trivial” Bug That Took 3 Hours

Tracing the Signal

Building a Clean Pipeline Between Labeling and ML

The Script

Balancing Work, AI Assistance, and Breaks

Wrap‑Up

Soul in Motion — 12:48 AM | 2026-09-27

TL;DR

Breathing Life into the Grid

Lighting Pipeline

Furniture Overhaul

User‑Driven Customization

The Business Audit & Manifest

Financial & Strategic Audit

Manifest Project

The Champions League Anchor

Closing Thoughts

Soul in Motion — 5:28 PM | 2026-09-21

TL;DR

Morning: Ripping Apart the Soul in Motion Palette

Implementation Snapshot

Afternoon: Debugging the Celestial Distance Visualizer

Inspiration Hunt

File System Clean‑Up

Wrap‑Up

Soul in Motion — 6:17 PM | 2026-09-18

TL;DR

A Day in the Life of a Builder – September 4

The Dashboard Dilemma

Recurring Bug in the Feature Toggle Service

Voice Recognition Tweaks for Soulvoice

Structured Play Parser

Breaks and Side‑Projects

Reflections

Soul in Motion — 6:16 PM | 2026-09-17

TL;DR

From Page to Space: Making Frankenstein Breathable

The Invisible Air Effect

Scaling Up: From One Book to a Shelf

Deployment Pipeline

Translating Complexity into Clarity

Kathaverse: Minimalist Short Stories

Comic Strip Smoothness

Personal Recharge

Day in Review

Soul in Motion — 6:20 PM | 2026-09-14

TL;DR

Morning – Soulvoice

Friday – Assistant on the Phone

Afternoon – Living‑Books

Legal Work

YouTube Pipeline Dashboard

Evening

Looking Back

Soul in Motion — 6:15 PM | 2026-09-11

TL;DR

The Morning: When “It Works Yesterday” Breaks Today

The Device Test: Real‑World Reality Check

Afternoon: Living‑Books – Making Stories Feel Like Places

Breaks That Keep the Brain Fresh

Evening Reflection: From Frustration to Relief

What Did You Get Done Today?

Soul in Motion — 6:16 PM | 2026-09-10

TL;DR

From Page to Space: Making Frankenstein Breathable

The Invisible Air Effect

Scaling Up: From One Book to a Shelf

Deployment Pipeline

Translating Complexity into Clarity

Act I – The Villain Called “Cost”

Act II – The Stars as Data

Act III – Voices of Living Books

Act IV – Nightfall, a New Beginning

A Day in the Life of a Builder – September 4

The Daily Grind – 5:56 PM

Project C – Incremental Core Logic