A personal reflection on coding with agentic AI, learning MCP servers on the job, and why the real skill may be shifting away from prompting alone toward orchestration, review, context management, and keeping the engineering quality bar high.
A short personal note on idempotency, why repeated requests can create duplicate records, and how I think about it when syncing users from third-party systems.
A practical reflection on database triggers, Laravel model observers, and events or jobs, based on real experience with hidden side effects, debugging pain, team visibility, and the trade-offs between database-level and application-level behavior in Laravel systems.
A practical walkthrough of how I planned and built a GitHub OAuth login flow using a Go backend, a React frontend, and PostgreSQL, while using AI coding help as an assistant to speed up delivery without giving up technical judgment, structure, or control over the implementation.
A practical, engineer-focused breakdown of how to model time entries and money values without precision loss, why float and rounded decimal approaches can introduce subtle reporting bugs, and why storing values as integers in the smallest unit (minutes or cents) is often the safest long-term design.
A nostalgic journey through JavaScript's evolution—from raw vanilla JS and jQuery dominance to the React/Vue revolution and the maturation of the modern web ecosystem.
A practical, no‑hype comparison of GUI vs command line tools, why teams argue about them, and why knowing your tools matters more than the interface itself.
A practical, human-centered reflection on three major backend paradigm shifts: SOAP to REST, XML to JSON, and the evolving monoliths vs microservices conversation, with real-world trade-offs and lessons developers can apply to modern systems.
A throwback tour of classic text editors and IDEs—Notepad, WordPad, Dreamweaver, Notepad++, and Vim—plus what WYSIWYG meant and why old tools still spark nostalgia.
A candid take on how toxic workplaces harm growth, confidence, and mental health—and why bad experiences do not make you better, even if people claim they do.
A nostalgic throwback story about deploying code with FTP and FileZilla before modern CI/CD pipelines, including the manual steps, risks, and adrenaline of old‑school releases.
A practical, learner-friendly exploration of automation vs reliability in software engineering, including why automation feels powerful, what reliability means in day-to-day systems, where the two align, and how to make safer trade-offs with clear guardrails.
A practical introduction to AI assistant rules in tools like Codex and Cursor, including what rules are, why they improve consistency and productivity, and how to start creating your own rule set for day-to-day engineering work.
A practical and developer-friendly comparison of `sprintf` and string interpolation in PHP, including readability trade-offs, formatting control, and guidance on when each approach makes the most sense in real codebases.
A beginner-friendly but practical explanation of Data Transfer Objects (DTOs), why they matter for clean application architecture, where they improve maintainability, and when they may or may not be worth introducing.
A personal 2025 review reflecting on growth, lessons, burnout, confidence, and the human side of software engineering—what changed, what stuck, and what I am taking into 2026.
A beginner-friendly and practical introduction to `grep`, with real command examples for searching files faster, filtering results with confidence, and building command-line muscle memory you can use every day.
A practical list of essential tools every programmer should have in their toolbox, from IDEs to databases, plus why each one actually matters in real work.
Five unexpected tools a senior developer uses daily, with practical reasons, real workflows, and how each tool helps solve problems beyond just writing code.
A practical guide to PostgreSQL B-tree and GIN indexes, explaining how each structure works, when to use one over the other, and how indexing choices impact real-world query performance and search behavior.
A practical walkthrough of five essential Go commands and project setup habits for everyday development, including module initialization, running and building apps, testing confidently, and staying productive with clean local workflows.
A beginner-friendly explanation of why `main.go` is the standard Go entry file, how Go discovers your application start point, and how naming conventions improve project clarity, team collaboration, and long-term maintainability.