Software Development Logs

Reviewing how descriptive statistics and visualizations explain center, spread, and distribution shape

A Python solution using Kadane's algorithm to find the maximum sum of a contiguous subarray

A Python backtracking solution to Combination Sum using a start index and pruning

Building a source-scoped RAG pipeline and validating its effect on real Study responses

A lesson note on filtering data, creating values, and aggregating groups with Pandas

A lesson note on vectors, matrices, NumPy arrays, shape, axis, and basic array operations

A Python solution that counts 1 bits by repeatedly dividing by 2

A two-pointer Python solution for checking palindromes after normalizing alphanumeric characters

Notes on Python sequences, file I/O, duplicate removal using sets, and OOP fundamentals covered in the second class of Codeit Sprint Main Course.

A DFS Python solution for checking whether a BST is built with valid value ranges

A first-class Codeit Sprint note on data science, MLOps, and Python basics.

A 3Sum solution using sorting and a two-sum-style hash map approach.

A left-product and right-product solution for Product of Array Except Self.

A recursion and memoization write-up for the Climbing Stairs problem.

A learning note on how hypothesis functions, loss functions, partial derivatives, and gradient vectors lead to gradient descent.

A comparison of sorting and character counting for the Valid Anagram problem.

Solving the rob-or-skip choice with top-down DP and memoization

Using a set to count each consecutive sequence only from its starting point

Using frequency counting and bucket arrays to return the top k frequent elements

Comparing brute force, two-pass hash map, and one-pass hash map approaches for Two Sum

Stabilizing live interviews by defining reliable boundaries for user and assistant turns

Comparing brute force, sorting, and hash set approaches for duplicate detection

A system design practice note on separating real-time LLM serving from asynchronous feedback collection at 20K peak TPS

Solving BST range sum through BFS, DFS, and prefix sums

A learning note on linear regression, mean squared error, and why the loss function takes theta as input.

A learning note on partial derivatives and gradients from a machine learning fundamentals course

A Codeit AI Engineer Sprint note on reviewing functions, rates of change, and the basic idea behind derivatives

A system design note on asynchronous document processing, GPU workers, queues, and storage choices for Document AI

Why a modified Bellman-Ford approach fits the K-stop constraint better, and some implementation notes

A summary of matrix addition, scalar multiplication, matrix multiplication, element-wise multiplication, and NumPy operations

Reviewing the fundamentals of machine learning and introductory linear algebra in the Codeit pre-course.

A Codeit AI Engineer Sprint pre-course note on dictionary view objects, string immutability, and Python indexing

A short Codeit AI Engineer Sprint pre-course note on revisiting Python lists and for loops

A short note from the Codeit AI Engineer Sprint pre-course on reviewing Python basics, PEP 8, and scope

Returning to a structured learning routine to keep growing as a hands-on engineer in the AI era

Managing Gemini Live credentials and long-lived sessions through a backend WebSocket relay

Managing voice opt-in, waiting, playback, and cancellation as one product flow

Aligning Kovill’s reply style, question progression, and language with product-owned state

Adding standalone coding practice without breaking the existing session and dashboard flow

Removing software-interview assumptions to support interview practice across professions

Evaluating full interview conversations with a typed LLM-as-a-Judge pipeline

Building credits, consent, and operational boundaries before accepting payment

Establishing identity, request, and deployment boundaries before the v1 launch

Recovering interview control flow lost during a prompt and grounding refactor

Enforcing LLM cost limits in the backend and modeling their operational impact

Treating active sessions as resumable work while preserving truthful progress

Connecting spaced review to a landing-page story without letting RPG flavor obscure the product

A Tail Villain note on treating LLM completion signals as advisory instead of letting them end sessions unconditionally

A Tail Villain note on study telemetry and the move toward a roadmap-level interview hub

Turning study mode from a one-off chat into a session with state, progress, and a report

How interviewer personas moved from a selection UI into distinct interview and study flows

What bilingual support revealed about local UI state, account preferences, and dashboard structure

Connecting interview results to topic progress, review timing, and the practice loop

Provider boundaries, latency handling, and failure modes that surfaced while wiring Gemini and Ollama into the same product

The polling bug that made completed backend analysis keep looking like it was still running

I pressed the button and waited thirty seconds. Technically, nothing was wrong. That was the problem.

The starting point of Tail Villain, built around the gap between knowing something and retrieving it under interview pressure