DEV Community: Dev Rajput

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.

Soul in Motion — 1:43 PM | 2026-08-31

Dev Rajput — Mon, 31 Aug 2026 08:34:56 +0000

TL;DR

Identified a privacy issue from user feedback and dug into the root cause.
Implemented tighter data handling and clearer UI cues to improve trust.
Balanced rapid fixes with deeper analysis of pacing in a popular show.
Kept the day productive with routine bookkeeping and incremental improvements.

The Day in a Nutshell

I started the morning after someone flagged a privacy concern that had surfaced in a recent session. It wasn’t a catastrophic bug—just a subtle lapse that could erode user trust. The real challenge was turning that complaint into a systemic improvement.

From Feedback to Insight

I pulled the user’s comment and a handful of similar notes from our issue tracker. The goal was to separate the surface complaint from the underlying pattern. In practice that meant:

Mapping the data flow: Where was the personal information captured, stored, and transmitted?
Identifying the weakest link: Was it an accidental data leak, an ambiguous consent prompt, or a missing encryption step?

The pattern that emerged was a lack of explicit consent and weak encryption on a few endpoints that handled user profiles.

Concrete Fixes

By midday I had a concrete plan:

Data Minimization
- Strip unnecessary fields from the User model before persisting.
- Use a SELECT projection to fetch only what the UI needs.
Encryption at Rest

   ALTER TABLE users
   ADD COLUMN encrypted_email VARBINARY(256) NOT NULL;
   UPDATE users SET encrypted_email = AES_ENCRYPT(email, :encryption_key);
   ALTER TABLE users DROP COLUMN email;

Clear Privacy Cues
- Updated the consent modal to use plain language and a single “Agree” button.
- Added a tooltip on the profile edit page explaining why each field is required.

These changes were low‑impact but high‑value: no new features, just a tighter grip on personal data.

Lunch & Reflection

I ate lunch while watching the Test match between Australia and Bangladesh. A multi‑day cricket game feels oddly grounding when you’re knee‑deep in code. It reminded me that some problems—like pacing in a show—are just as much about rhythm as they are about content.

The Afternoon Dive

Later, I got sidetracked by a question that had been nagging me: why does the first season of a highly‑rated show feel sluggish? I spent a few hours watching episodes, noting pacing, episode length, and narrative structure. It turned out to be a pacing issue rather than a lack of quality. I documented my observations and shared them with the content team for future reference.

Routine Bookkeeping

I also tackled some bookkeeping: updating the sprint backlog, reconciling the budget spreadsheet, and reviewing the CI pipeline logs for any anomalies. These unglamorous tasks keep the project from derailing.

Evening Wrap‑Up

By the end of the day, the privacy fix was merged, the UI cues were live, and the pacing notes were in the shared doc. No drama, just incremental progress toward a product that earns trust.

Technical Takeaways

1. Privacy by Design

Data Minimization: Only collect what you need.
Encryption: Use AES‑256 for sensitive fields.
Consent: Explicit, granular, and revocable.

2. Rapid Feedback Loops

Pull user feedback directly into your issue tracker.
Prioritize fixes that affect trust or security over cosmetic changes.
Deploy small, reversible changes to gauge impact.

3. Balancing Speed and Depth

Quick fixes are essential, but don’t ignore deeper patterns.
Use the time between fixes to dig into root causes—whether it’s data handling or content pacing.
Document findings for future reference; knowledge is a hidden feature.

Closing Thoughts

Today’s work was a reminder that the most valuable engineering effort often comes from listening to users and tightening the seams that hold their trust together. The next day will bring more feedback, more analysis, and more incremental steps toward a product that feels safe and reliable.

Stay tuned.

Soul in Motion — 2:05 PM | 2026-08-29

Dev Rajput — Sat, 29 Aug 2026 08:58:50 +0000

TL;DR

Spent the day juggling six different codebases, each moving a few percent forward.
Project C: Design sprint turned into a new game feel; morning collaboration, afternoon sanity‑check.
Chronicle: Focused on physics consistency in a 2D world—no new features, just trust.
Friday‑Phone: Debugged voice‑pipeline bug, screenshot‑by‑screenshot.
Manifest: Artistic alignment of crisis events and launch‑site sequence; visual direction finally clicked.
Manifest‑Unreal: Cross‑checked simulation core against browser build for parity.
Wrapped up with minor work on Transformed and Tmp; laid groundwork for future features.

A Day in the Life of a Multi‑Project Builder

Project C – The Never‑Ending Ladder

The morning started with a design call for Project C. A friend sent over a rough idea for the game’s feel, and the conversation quickly turned into an argument‑as‑collaboration. We debated pacing, control responsiveness, and the visual style until we landed on a concept that felt tighter than the last iteration. By lunch the scope had shifted just enough to keep the momentum going without derailing the sprint.

After the design freeze, I spent the afternoon running sanity checks on the new assets and ensuring the ladder mechanics still behaved as expected. It’s the kind of work that feels invisible until something breaks, but it’s the foundation that keeps the rest of the project stable.

Chronicle – Precision Over Speed

Chronicle is a 2D simulation that relies on accurate physics to feel believable. I dedicated a long stretch of the day to tightening the world’s behavior: collision detection, gravity scaling, and object interactions. No new features were added; the goal was to make the existing mechanics trustworthy.

This kind of work is often overlooked, but a world that “holds together” is the difference between a fun experience and a chaotic mess. I ran a suite of regression tests and manually stepped through edge cases to confirm consistency.

Friday‑Phone – Debugging the Voice Pipeline

In the afternoon, Friday‑Phone demanded a different kind of patience. I chased a bug through the assistant’s voice pipeline, capturing screenshots at each stage to isolate the failure point. The process was incremental: tweak a parameter, re‑run, capture, compare. Each small step was a win, and eventually the voice output behaved as intended.

Manifest – Artistic Alignment

The day’s next stop was Manifest, where I focused on crisis events and the launch‑site sequence. The goal was to align the art direction with the narrative flow. I iterated on asset placement, timing, and visual cues until the system finally looked like the vision I’d imagined weeks ago. Seeing the art direction click into place was a relief that reminded me why the creative side matters as much as the code.

Manifest‑Unreal – Cross‑Platform Consistency

Evening brought Manifest‑Unreal, a cross‑checking exercise between the simulation core and its browser counterpart. I ran both builds side‑by‑side, comparing physics outputs, frame rates, and asset loading times. The meticulous work paid off: both builds now agree on key metrics, ensuring a consistent experience across platforms.

Transformed & Tmp – Laying Bricks for the Future

I wrapped up the day with quick passes on Transformed and Tmp. These were not breakthrough moments but essential housekeeping: refactoring a few functions, tightening type annotations, and adding a couple of unit tests. Small, incremental work that keeps the codebase healthy.

Side Notes & Reflections

Between the code, I let my mind wander a bit:

Netflix: A quick break with Rocket Singh—a grounded, funny sci‑fi that was a nice left turn from my usual diet.
ChatGPT & VS Code: Tinkered with a fresh Visual Studio install and experimented with ChatGPT prompts to see how it could aid my workflow.
Eli’s Live Build: Checked in on Eli’s live build to see how she’s holding up in production.

Looking back, the day wasn’t defined by a single big win. It was defined by momentum: six projects nudged forward, none finished, all a bit more real than they were in the morning. That’s the essence of building—just moving forward, one commit at a time.

Onward to tomorrow.

Soul in Motion — 3:06 PM | 2026-08-27

Dev Rajput — Thu, 27 Aug 2026 10:00:58 +0000

TL;DR

Re‑engineered Horizon’s auth flow to be both secure and user‑friendly, adding graceful error handling for mistyped passwords, dropped connections, and double submissions.
Experimented with a Rails‑based LLM that auto‑generates code from plain‑English descriptions; early results show promise but still need refinement.
Audited Eli’s UX to eliminate friction points, enabling seamless re‑entry after breaks and reducing silent churn.
Added six customizable “rooms” (light/dark, warm/quiet) to Eli, giving users contextual environments that influence comfort and engagement.
The core mantra, “Free AI can answer you. Eli is built to hold you.”, drives every design and implementation decision.

Re‑thinking Authentication in Horizon

The first half of the day was all about the login flow. I had been iterating on Horizon’s authentication for weeks, each pass tightening security while shaving latency. The last iteration finally felt right: a single‑page login that validates credentials via a GraphQL mutation, then issues a short‑lived JWT and a refresh token stored in an HTTP‑only cookie.

Graceful Failure

What really mattered was the experience when something went wrong. Instead of a generic “invalid credentials” page, I wrapped the mutation in a try/catch block that catches:

AuthenticationError – wrong password
NetworkError – dropped connection
ValidationError – double submission

Each error maps to a specific, user‑friendly message:

def handle_login_error(error)
  case error
  when AuthenticationError
    flash.now[:alert] = "That username or password doesn't match our records."
  when NetworkError
    flash.now[:alert] = "Connection lost. Please check your internet and try again."
  when ValidationError
    flash.now[:alert] = "We detected a duplicate request. Please wait a moment."
  else
    flash.now[:alert] = "Something went wrong. Try again later."
  end
end

The messages are intentionally vague enough to avoid giving attackers hints, yet specific enough to guide legitimate users. I also added a debounce on the submit button to prevent double submissions at the UI level.

Invisible but Critical

These changes are buried three layers deep: the GraphQL resolver, the Rails controller, and the front‑end component. No one sees them unless something breaks, but when they do, the system fails kindly. That’s the kind of invisible kindness I like to build.

Rails + LLM: Turning Sentences into Code

After Horizon settled, I dove into a side project: a Rails app that uses an LLM to generate Ruby code from plain‑English prompts. The goal is to prototype a “code‑as‑service” layer that could one day power Eli’s dynamic room generation.

Architecture

Prompt Engine – a thin wrapper around OpenAI’s gpt-4o-mini API.
Code Validator – runs the generated code through rubocop and a unit‑test harness to catch syntax errors.
Feedback Loop – user corrections are fed back into the prompt to improve future generations.

# Gemfile
gem 'openai', '~> 3.0'
gem 'rubocop', '~> 1.50'

class CodeGenerator
  def initialize(prompt)
    @prompt = prompt
  end

  def generate
    response = OpenAI::Client.new.chat(
      model: "gpt-4o-mini",
      messages: [
        { role: "system", content: "You are a helpful Ruby developer." },
        { role: "user", content: @prompt }
      ]
    )
    response.dig("choices", 0, "message", "content")
  end

  def validate(code)
    result = RuboCop::Runner.new([], []).run(code)
    result.empty?
  end
end

Early Results

The model sometimes produces a working snippet on the first try, especially for straightforward tasks like “create a Rails migration for a users table.” More complex logic, like a service object that interacts with an external API, still requires a few rounds of correction. Still, the fact that it can generate a complete method from a single sentence is a glimpse of what a future AI‑assisted developer might look like.

Eli: From One Room to Six

Eli is a conversational companion built on top of the same authentication stack. The second half of the day was dedicated to polishing the user journey.

UX Audit

I walked through every point where a user might silently lose interest:

Session Expiry – implemented silent refresh using the refresh token.
Navigation Gaps – added “Continue where you left off” prompts.
Onboarding – simplified the first‑time flow to a single screen.

These fixes reduce friction and keep users engaged.

The Six Rooms

The real fun came with the “rooms” feature. Each room is a pre‑configured set of UI themes and background audio that changes the user’s context:

Room	Theme	Audio
1	Light, warm	Café chatter
2	Dark, quiet	Library hush
3	Light, cool	Beach waves
4	Dark, warm	Fireplace crackle
5	Light, neutral	City traffic
6	Dark, cool	Night sky

The implementation is a simple Rails view component that swaps CSS variables and plays an audio stream via the Web Audio API.

class RoomComponent < ViewComponent::Base
  def initialize(room:)
    @room = room
  end

  def theme_css
    @room.theme_css
  end

  def audio_url
    @room.audio_url
  end
end

<div class="room" style="<%= theme_css %>">
  <audio autoplay loop src="<%= audio_url %>"></audio>
  <%= render @content %>
</div>

Users can switch rooms on the fly, and the app remembers their last choice in a user_room column on the users table.

The Core Mantra

A line I’d written weeks ago kept resurfacing: “Free AI can answer you. Eli is built to hold you.” That sentence is the north star for every decision:

Free AI – the LLM that powers code generation and conversational responses.
Hold you – the gentle error handling, the frictionless re‑entry, the comforting rooms.

Everything else—login flow, six rooms, quiet error messages—serves that promise.

Evening Reflections

I wrapped up the day with a mix of media: Rick and Morty for a dose of chaos, Boardwalk Empire for sharp dialogue, a Joe Rogan clip for a lighter tone, and an unexpected America’s Got Talent episode that actually kept me engaged. It’s a reminder that even when the code is solid, life still needs a little entertainment.

Looking Ahead

Horizon – still adding analytics to monitor authentication success rates and failure reasons.
LLM Code Generator – need to improve the feedback loop and add a sandbox for safe execution.
Eli – rooms are built, but I’ll start A/B testing to see which environments drive the most engagement.

The system that used to fail loudly now fails kindly, and a companion that had one room now has six. Tomorrow I’ll test whether these changes hold up under real traffic and user feedback.

Soul in Motion — 1:34 PM | 2026-08-26

Dev Rajput — Wed, 26 Aug 2026 09:50:13 +0000

TL;DR

The idea of building a character for survival on Mars transformed into a platform where users can create and customize their own characters.
The author realized that the work he was doing for different projects was essentially the same, leading to questions about his true interests.
By the end of the day, the author had connected two seemingly separate tasks and felt curious about pursuing this thread further.

Building Our Character

Morning Reflections

Today started with a half-joking question in conversation: what if someone had to build a version of themselves that could survive thirty days on Mars and then jump off? It shouldn't have gone anywhere, but it stuck with me all morning. By midday, it transformed into a real idea—a platform where people don’t just play a character; they build one, piece by piece.

The Scaffolding

So, that became the day’s focus. I opened a blank page and started with what you always have to start with: not the exciting part, but the scaffolding underneath it. What does a character actually consist of, mechanically? How do traits connect to abilities, and how does the whole structure hold together well enough for someone with no idea any of this exists to just click a few things and watch a person take shape?

By the end of the afternoon, the skeleton was there. Not impressive to look at, but necessary—the kind of work nobody notices unless you skip it.

Accidental Realization

Almost by accident, I noticed something. A few desks over—metaphorically, in another project running quietly in the background—I was doing the exact same thing for a completely different reason: building out voices and personalities for Eli, a companion character who needed to feel real and personal.

The question kept circling back to me today: what if people could choose a personality they actually connect with? Not one voice trying to be right for everyone—several, each with its own texture, so that whoever's on the other end of the conversation finds the one that feels like it’s actually listening to them.

Testing the Idea

I spent the afternoon testing this idea in practice. Building out different “modes,” adjusting how a scene feels depending on which version of Eli someone chooses. A landing page that sets the tone before a single word is spoken, and a quieter, cozier space for when someone needs exactly that. Small differences, but the kind that decide whether something feels alive or like software.

Connecting the Dots

By evening, I realized I’d basically spent the whole day doing the same work twice—in two different disguises: once for a character someone builds for fun, once for a companion built to actually matter. Which raises a question I don't have an answer to yet: is that a coincidence, or is it just what I’m actually interested in right now, wearing two different names?

Reflecting on the Day

I let the day breathe where it needed to. A rewatch of Kingdom crept back in—Season 3 still owes its viewers an ending it hasn’t fully delivered. A couple of episodes of Rick and Morty, chaotic in exactly the right dose. An old Boardwalk Empire episode for its dialogue, which never stops teaching me something about pacing even when I’m not trying to learn anything. And somewhere in the middle of it all, a long Joe Rogan conversation with Elon Musk playing in the background—two people thinking out loud about the future in a way that kept nudging me back toward the two projects sitting open on my desk.

Nothing got finished today. The character tool is a skeleton, not a person yet. Eli’s voices are still rough sketches of what they’ll eventually become. But something clicked into place that wasn’t there this morning—a thread connecting two things I’d been treating as separate—and a genuine curiosity about where it leads if I actually follow it instead of letting it stay a coincidence.

Tomorrow's Plan

Tomorrow I find out.

Soul in Motion — 11:13 AM | 2026-08-22

Dev Rajput — Sat, 22 Aug 2026 07:19:16 +0000

TL;DR

Precision in pixel alignment is crucial but often unnoticed.
Script refinement involves cutting down unnecessary elements to enhance clarity and realism.
Taking breaks with engaging content helps maintain mental focus and creativity.

Building Dreams, One Frame at a Time

11:13 AM

Some days the work is invisible until it suddenly isn't. Today was one of those.

Pixel Perfect Precision

I spent the morning deep in the mechanics of Pixel Perfect — the unglorious, exacting work of making sure every image lines up exactly where it's supposed to, down to the pixel. It’s the kind of task that looks like nothing from the outside: numbers, ratios, small corrections applied over and over until an image that was scaled and resized and moved finally sits back in its original place, seamlessly, as if it had never been touched at all.

// Example of a function for pixel alignment
function alignPixel(image) {
  const canvas = document.getElementById('canvas');
  const ctx = canvas.getContext('2d');

  // Resizing and positioning logic here
  ctx.drawImage(resizedImage, newX, newY);
}

There’s a strange satisfaction in that kind of precision — nobody will ever notice it when it's right, and everybody would notice instantly if it were wrong. It’s the kind of work where you can spend hours on a single pixel, tweaking until it aligns perfectly with its neighbors.

Crafting Narrative Flow

By afternoon I shifted into the part of the work I care about even more — narration. Getting a script to actually sound like something a person would say, not something a machine assembled. I went back into a scene I’d been circling for a few days — "The First Scene," the opening of the whole project — and instead of adding more to it, I found myself doing the opposite: cutting it down, stripping away anything that wasn't earning its place.

# Example of a script snippet before refinement
---
Scene: The First Scene
Characters:
  - Alex
  - Sarah

Lines:
  1: "Alex: 'Hey, Sarah! How's your day going?'"
  2: "Sarah: 'It's been okay. Just a bit busy at work.'"
  3: "Alex: 'That sounds tough. Do you want to grab lunch and chat?'"
  4: "Sarah: 'Sure, that would be nice.'"
---

By the end of the afternoon, the scene finally sounded like itself:

# Example of a refined script snippet
---
Scene: The First Scene
Characters:
  - Alex

Lines:
  1: "Alex: 'Hey, Sarah! How's your day going?'"
  2: "Sarah: 'It's been okay. Just a bit busy at work.'"
  3: "Alex: 'That sounds tough. Do you want to grab lunch and chat?'"
---

It’s a strange thing to learn, over and over, that the version with less in it is usually the one that actually works. By stripping away extraneous dialogue and focusing on essential interactions, the scene felt more natural and engaging.

Taking Breaks for Mental Reset

I let myself take real breaks today too — a few episodes of Rick and Morty, which is exactly the right kind of chaos to reset a tired brain. The show’s blend of humor and surrealism provides just enough distraction without overwhelming my focus. Later, I watched The Invite, which held onto its tension long enough to be genuinely absorbing rather than just background noise.

I also let a long Joe Rogan conversation run in the background for a while — not for any particular insight, just the low hum of two people actually talking to each other, which is oddly good company when you’ve spent all day talking to a screen. The sound of human interaction can be surprisingly soothing and grounding.

Reflecting on Progress

Looking back, nothing about today announced itself as a big moment while it was happening. But somewhere between the pixel math and the stripped-down script, something shifted — the project feels less like a pile of separate pieces today and more like one thing, slowly becoming itself. That’s usually how it goes. The good days rarely feel dramatic while you’re inside them. You only notice later that something actually moved.

Until next time.

Soul in Motion — 11:05 AM | 2026-08-20

Dev Rajput — Thu, 20 Aug 2026 06:35:10 +0000

TL;DR

Fixed an issue where Eli would cut off mid-farewell.
Addressed routing bugs and wrote runbooks to prevent future issues.
Worked on converting spoken audio into clean text with various approaches.
Maintained general upkeep, ensuring the app runs smoothly.

Building Eli, One Small Fix at a Time

11:05 AM

Today started with fixing an issue in Eli, my companion app, where it would cut off mid-farewell. This bug was particularly frustrating because the whole point of Eli is to be present and complete with someone. The fix required careful attention to ensure that every word and emotion conveyed through the app remained intact.

Fixing the Mid-Farewell Bug

The issue turned out to be a simple yet annoying one: an improperly configured timeout in the speech synthesis module. When testing, I noticed that the audio cut off abruptly at certain points during goodbyes. To address this, I went through the code and identified where the timeout was set too low.

# Original Code
timeout = 3000  # Too short for long sentences

# Fixed Code
timeout = 5000  # Increased to ensure full sentences are spoken

After adjusting the timeout, I re-ran the tests and confirmed that Eli now spoke through complete goodbyes without any interruptions.

Chasing Down Routing Bugs

The rest of the day was spent addressing a routing bug where testers were receiving session links in their inbox instead of within the app. This required digging into the backend to ensure all routes were correctly configured.

# Original Route Configuration
app.get('/session/:id', (req, res) => {
  // Incorrect handling of session ID
});

# Fixed Route Configuration
app.get('/session/:user_id/:session_id', (req, res) => {
  // Correct handling of user and session IDs
});

To prevent such issues in the future, I wrote a runbook detailing common pitfalls and best practices for route configuration. This document will serve as a reference whenever someone needs to make changes to Eli's routing.

Converting Spoken Audio into Clean Text

In between tasks, I tackled another quieter project: converting spoken audio into clean text. This involved testing various speech-to-text APIs to achieve full accuracy. The process was iterative and required fine-tuning the parameters for each API to get the best results.

# Example Configuration for Speech-to-Text API
api_key: "YOUR_API_KEY"
model: "en-US_BroadbandModel"
language: "en-US"

After testing several APIs, I settled on one that provided high accuracy and decent speed. The next step was to integrate this into Eli's backend.

General App Maintenance

General upkeep also took its share of time. Ensuring the app ran smoothly without quietly bleeding money in the background was crucial. This involved monitoring resource usage and optimizing code where necessary.

# Example Command for Monitoring Resource Usage
top -b -n 1 | grep "Eli"

By the end of the day, five or six small fixes had piled up—nothing that will make headlines, but each one made Eli a little more trustworthy. Building something like Eli is mostly about these small acts of care, invisible to everyone except those who need them most.

Reflecting on the Day

I took my breaks seriously today, maybe more than usual. In the morning, Train to Busan, a film about people trying to protect each other when everything is falling apart, felt oddly close to the work on my desk. I watched Rick and Morty in smaller doses throughout the day, and even found myself watching Boardwalk Empire again.

By the end of the day, as the sun set, I let the quiet sit for a bit before going back in. Tomorrow there'll be more of the same. For tonight, though, I'm letting the quiet settle in.

Stay tuned for more updates on Eli and my journey building it one small fix at a time.

Soul in Motion — 10:09 PM | 2026-08-12

Dev Rajput — Wed, 12 Aug 2026 20:12:34 +0000

TL;DR

Successfully migrated auto-upload pipeline to new Instagram handle @trendpulse77 using Claude.
Optimized running-scene footage for Omni, refining details for a more immersive experience.
Debugged and refined user experience for Eli, resulting in a smoother app.

Building Dreams, One Line at a Time

Today was one of those days where the work put up a fight. It started with a stubborn problem on Soul in Motion - moving our auto-upload pipeline to a new Instagram handle, @trendpulse77. What seemed simple on paper turned out to be a complex task, like untangling months of working plumbing without breaking anything that depended on it.

The main issue was that our previous pipeline relied heavily on environment variables and hardcoded paths, which made it difficult to adapt to the new Instagram handle. I decided to leverage Claude, our trusty AI-powered tool, to help me refactor the pipeline. With Claude's assistance, I was able to identify and replace the hardcoded values with dynamic variables, making the pipeline more flexible and scalable.

Here's a snippet of the refactored pipeline in Python:

import os
import boto3

# Load environment variables
instagram_handle = os.environ['INSTAGRAM_HANDLE']
access_token = os.environ['INSTAGRAM_ACCESS_TOKEN']

# Initialize Instagram API client
instagram = boto3.client('instagram', aws_access_key_id=os.environ['AWS_ACCESS_KEY_ID'],
                         aws_secret_access_key=os.environ['AWS_SECRET_ACCESS_KEY'])

# Upload media to Instagram
def upload_media(media_path):
    # ...

With Claude's help, I was able to migrate the pipeline to the new Instagram handle without breaking any existing dependencies. The new account is now live and posting smoothly.

I also spent hours working on the running-scene footage for Omni, searching for the perfect starting frame and tweaking the details until it felt alive. I experimented with different camera angles, lighting setups, and even added some subtle particle effects to enhance the realism. Here's a snippet of the footage editing process in Blender:

# Create a new scene
scene = bpy.data.scenes.new('Running Scene')

# Set the camera angle and position
camera = bpy.data.objects['Camera']
camera.location = (0, 0, 10)
camera.rotation_euler = (0, 0, math.radians(45))

# Add a particle system
particle_system = bpy.data.particles.new('Running Particles')
particle_system.type = 'HAIR'
particle_system.settings.count = 1000
particle_system.settings.size = 0.1
particle_system.settings.factor = 1.0

And then there was Eli, where I was chasing down syntax errors and refining the user experience. Debugging can be a grind, but persistence paid off, and the app is now smoother than before.

Throughout the day, I took breaks to check on the new Instagram account, post a reel, and even watch some Rick and Morty. It was a day of triumph and grind, with no big breakthroughs, but I didn't walk away. I'm curious, what's the wall you're pushing against right now? What did your day look like?

Soul in Motion — 9:38 PM | 2026-08-10

Dev Rajput — Mon, 10 Aug 2026 16:23:34 +0000

TL;DR

Today was a day of juggling multiple projects and roles, from backend engineering to filmmaking and writing.
I worked on building a production pipeline for v2, which required translating a mental picture into a visual representation.
I also made progress on Soulmotion Films, Eli, and "Two Savages In Love", focusing on creative problem-solving and world-building.
The day was marked by small wins across different areas of thinking, including technical, visual, emotional, and creative.

A Day in the Life of a Builder

Today was one of those days where I felt like three people at once - an engineer, a filmmaker, and a writer. My morning started with backend work on tsil, reading and writing files, and shuffling data around. It's not glamorous, but it's the foundation that everything else is built on.

# Reading and writing files with tsil
tsil read data.json
tsil write output.csv

I then moved on to v2, where I worked on piecing together a production pipeline. I found myself staring at reference images, trying to translate the picture in my head into a picture on screen. This kind of problem-solving is half logic and half instinct.

# Example of a production pipeline in v2
import cv2
import numpy as np

def process_image(image_path):
    # Load the image
    image = cv2.imread(image_path)

    # Apply filters and transformations
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    image = cv2.resize(image, (800, 600))

    # Save the processed image
    cv2.imwrite('output_image.jpg', image)

process_image('input_image.jpg')

The day took a creative turn with Soulmotion Films, where I wrote shot lists and color scripts. I also worked on Eli, giving her a better sense of reasoning and making sure conversations didn't feel clipped. I chased a text-to-speech reader through a few frustrating rounds, but eventually landed on the right prompt and got the desired output.

# Example of a text-to-speech reader in Eli
import nltk
from nltk.tokenize import word_tokenize

def text_to_speech(text):
    # Tokenize the text
    tokens = word_tokenize(text)

    # Generate the speech
    speech = ''
    for token in tokens:
        speech += token + ' '

    return speech

text = 'Hello, how are you?'
print(text_to_speech(text))

I also worked on "Two Savages In Love", building a world and brainstorming scenes without any deadlines or specs. It's a challenging but freeing project. Throughout the day, I gave myself real breaks, watching an episode of "The Agency" and sorting out notes for a job application.

Looking back, today didn't have one big win, but six small ones across different kinds of thinking - technical, visual, emotional, and creative. That's the part of building things that doesn't show up in a commit log: the constant switching and staying steady through it all. Tomorrow, I'll pick up where I left off. Onward.

Soul in Motion — 6:29 PM | 2026-08-07

Dev Rajput — Fri, 07 Aug 2026 13:06:56 +0000

TL;DR

Reduced file upload times by nearly a third through backend optimizations.
Improved interface usability by addressing underlying complexities.
Utilized breaks to stay grounded in the field, inspired by others' work on Kaggle.
Achieved real-time responsiveness through focused coding efforts.
Emphasized the importance of unglamorous progress in building towards a future goal.

Building the Future, One Line at a Time

Today was a marathon, with no single big breakthrough, but steady progress nonetheless. I started early, tackling backend work, and managed to reduce file upload times by nearly a third. This was achieved by optimizing the file handling pipeline, which involved tweaking the buffer sizes, adjusting the concurrency settings, and fine-tuning the compression algorithms. The changes were implemented in the following code:

# Adjusting buffer sizes
file_buffer_size = 1024 * 1024 * 10  # 10MB

# Adjusting concurrency settings
max_concurrency = 5

Later, I worked on making the interface more effortless to use, which proved to be a harder problem than it sounds. I realized that the issue was not just about simplifying the UI, but also about addressing the underlying complexities of the system. This involved refactoring the code to make it more modular, adding better error handling, and implementing a more intuitive navigation system. The changes were implemented in the following code:

# Refactoring the code to make it more modular
class UIComponent:
    def __init__(self):
        self.components = []

    def add_component(self, component):
        self.components.append(component)

# Adding better error handling
try:
    # Code that might raise an exception
except Exception as e:
    # Handle the exception
    print(f"Error: {e}")

# Implementing a more intuitive navigation system
def navigate_to_page(page):
    # Code to navigate to the page
    pass

I took breaks to watch "A Few Good Men" and read about its history, and later listened to Joe Rogan's conversations on comedy and politics. I also dropped into Kaggle to see what others are working on, which helps me stay grounded in the field. It's amazing how often I find inspiration in the work of others, and how it motivates me to push forward on my own projects.

The late afternoon was all about escapism, with episodes of "Avatar: The Last Airbender" and "Spider-Man: Far From Home". Sometimes, stepping away from a project can be the most useful thing you can do. It allows you to clear your mind, recharge your batteries, and come back to the project with a fresh perspective.

I spent the evening coding, working towards real-time responsiveness, and watching a few episodes of "Boardwalk Empire" and "Avatar: Fire and Ash". I even caught some fight highlights, which can be oddly motivating for a late coding session. The focus was on optimizing the rendering pipeline, reducing latency, and improving the overall user experience. The changes were implemented in the following code:

// Optimizing the rendering pipeline
function render() {
    // Code to render the scene
    requestAnimationFrame(render);
}

// Reducing latency
setInterval(() => {
    // Code to update the scene
}, 16); // 16ms = 60fps

Looking back, today was all about unglamorous progress - a faster upload, a cleaner interface, a system that speaks up when something's wrong. It may not be dramatic, but it's exactly what's needed to keep moving forward. Stay curious, keep building.

Soul in Motion — 11:44 AM | 2026-08-05

Dev Rajput — Wed, 05 Aug 2026 06:26:25 +0000

TL;DR

Crafting short films with a cinematic feel using Blender.
Building a portfolio and navigating the job hunt.
The importance of taking breaks and allowing oneself to play and experiment.
Trusting the process and taking small steps towards a goal.

A Day in the Life of a Blender Artist

Today was all about Soulmotion Films. I spent hours building something frame by frame, deciding on lighting, dialogue, and pauses. My goal is to make these short films feel as real as something out of Avatar, but most days that bar feels impossible. Today, a few scenes finally started to close the gap, making the slow grind worth it.

# Blender scene hierarchy
Scene > Object > Material > Texture

As I worked, my mind wandered to my portfolio and job hunt. I shaped my portfolio, pulling pieces from other projects to make a case for myself. A harder question emerged: is any of this actually enough? It's not a comfortable question, and I didn't fully answer it today. But I let myself ask it honestly, which felt like progress.

The Importance of Experimentation

I also gave myself permission to just play, rigging and posing without production pressure. It's the part of the work that feels like being a kid again. This is where the magic happens, and I often find inspiration in these moments of unstructured creativity.

# Blender Python script to create a simple rig
import bpy

# Create a new armature
armature = bpy.data.armatures.new("Simple_Rig")

# Add bones to the armature
bpy.context.collection.objects.link(armature)

In between, I took breaks with some Joe Rogan, scenes from Avatar: Fire and Ash, and Spider-Man: Far From Home. Reality knocked with administrative tasks, but by the end of the day, I was left with two truths: real progress on what I care about, and a question about the future that I still don't have an answer to.

Trusting the Process

I've decided that's okay – some days the job is just to keep building and trust that the small steps are pointed somewhere. It's a mindset shift that I'm still working on, but it's one that I believe is essential for making progress in creative pursuits.

# Blender render settings
render:
  resolution: 1920x1080
  frame_rate: 24
  render_engine: CYCLES

In the end, it's not about having all the answers or achieving perfection. It's about taking small steps towards a goal, trusting the process, and allowing oneself to learn and grow along the way.

DEV Community: Dev Rajput

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

TL;DR

Building Friday‑Phone

The Listening Problem

Diagnosing the Slowdown

Project C – Incremental Core Logic

The “Forty Small Things” Mindset

Debugging the Assistant

Side Projects & Mental Reset

End‑of‑Day Routine

Reflections & Next Steps

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

TL;DR

The Daily Loop: From Doubt to Delivery

Building a Personal Assistant

Chronicle: Documenting Decisions

Tightening Wake‑Word Detection

Reflecting on Responsible AI

End‑to‑End Wake‑Word Test

What Building Friday Looks Like

Soul in Motion — 1:43 PM | 2026-08-31

TL;DR

The Day in a Nutshell

From Feedback to Insight

Concrete Fixes

Lunch & Reflection

The Afternoon Dive

Routine Bookkeeping

Evening Wrap‑Up

Technical Takeaways

1. Privacy by Design

2. Rapid Feedback Loops

3. Balancing Speed and Depth

Closing Thoughts

Soul in Motion — 2:05 PM | 2026-08-29

TL;DR

A Day in the Life of a Multi‑Project Builder

Project C – The Never‑Ending Ladder

Chronicle – Precision Over Speed

Friday‑Phone – Debugging the Voice Pipeline

Manifest – Artistic Alignment

Manifest‑Unreal – Cross‑Platform Consistency

Transformed & Tmp – Laying Bricks for the Future

Side Notes & Reflections

Soul in Motion — 3:06 PM | 2026-08-27

TL;DR

Re‑thinking Authentication in Horizon

Graceful Failure

Invisible but Critical

Rails + LLM: Turning Sentences into Code

Architecture

Early Results

Eli: From One Room to Six

UX Audit

The Six Rooms

The Core Mantra

Evening Reflections

Looking Ahead

Soul in Motion — 1:34 PM | 2026-08-26

TL;DR

Building Our Character

Morning Reflections

The Scaffolding

Accidental Realization

Testing the Idea

Connecting the Dots

Reflecting on the Day

Tomorrow's Plan

Soul in Motion — 11:13 AM | 2026-08-22

TL;DR

Building Dreams, One Frame at a Time

Pixel Perfect Precision

Crafting Narrative Flow

Taking Breaks for Mental Reset

Reflecting on Progress

Soul in Motion — 11:05 AM | 2026-08-20

TL;DR

Building Eli, One Small Fix at a Time

Fixing the Mid-Farewell Bug

Project C – Incremental Core Logic

Project C – The Never‑Ending Ladder