Topic
Delivery & Evolution
Deployment, migration, maintenance, and reversible ways to evolve real systems.
Split AI Development Work by Context, Device, and Risk
Combine IDE review, desktop agents, and a remote mobile workflow by assigning each task according to context size, inspection needs, and operational risk.
Evolve Development Templates from Observed AI Workflows
Update development templates from repeated AI-assisted use, while keeping validation explicit and project-specific instructions out of universal defaults.
Store Object Keys, Not File URLs
Design file uploads around stable object keys, server-composed delivery URLs, collision-resistant names, and separately retained original filenames.
Split AI Changes into Pull Requests Teammates Can Review
Keep AI-generated code accountable by narrowing scope, rebuilding coherent commits, and splitting risky changes into pull requests teammates can understand.
Make Overwork and Leadership Failures Visible
Turn engineering overload into visible work, shared evidence, and scoped escalation so teams can negotiate resources and expose recurring leadership failures.
Keep a Small Documentation Set the Team Can Trust
Reduce documentation sprawl by maintaining a trusted core of policy, concepts, system flows, and API contracts with clear ownership and onboarding feedback.
Oracle to MySQL Migration with Adapters, Dual Writes, and Flags
A reversible Oracle-to-MySQL migration using compatible adapters, dormant deployments, dual writes, tested switches, deliberate rollback, and legacy cleanup.
Code Review Health Is a Trend, Not a Comment Count
Use automation and draft pull requests to align teammates early, then track whether repeated feedback declines as shared conventions become real practice.
Account Deletion Data: Retention, Separation, and Recovery Design
Design deleted-account data around verified retention rules, isolated storage, encryption, expiry, and the operational flows that may still need recovery.
How to Break Long Legacy Migrations into Small, Deployable Steps
Break exhausting legacy work into small development, verification, and deployment increments that create feedback before a perfect rewrite.
Developer Testing Responsibility Before QA Handoff
Verify expected behavior before QA handoff so testers can pursue edge cases, reduce release loops, and build stronger cross-functional trust.
Improve a Bad Legacy Schema Behind a Code Boundary
Hide cryptic tables behind repositories and meaningful types, regain control in code, then approach improvements to the legacy database.
Split Batch Ingestion from Processing to Reduce Retry Cost
Stage external data, rerun internal transformations without repeating provider calls, and reduce the traffic and recovery costs of oversized batch jobs.
Refactor Spaghetti Code with Characterization Tests
Capture legacy behavior with broad API tests, refactor behind the safety net, and deploy small reversible changes while coverage grows.
Agile Does Not Mean No Documentation
Agile values working software without banning documentation. Write what teams, continuity, security, and regulated operations genuinely require.
Use ID Range Gaps for Safer Database Rollbacks
Separate legacy and new identifier ranges to prevent rollback collisions, simplify reverse migration, and make operational traffic easier to trace.
Split God Query Methods by Purpose
Replace universal dynamic queries with purpose-specific methods, migrate callers incrementally, and shrink the side-effect surface before deeper refactoring.
Legacy Cleanup Starts with Safe Dead-Code Removal
Shrink legacy systems safely by combining runtime evidence, database checks, API consumer verification, and incremental dead-code deletion.
Modernize Legacy Systems with Small Deployments
Reduce modernization risk with small verified deployments, practical rollback boundaries, visible progress, and value that survives a paused project.
Separate Domain Learning from Technology Experiments
Use familiar tools to launch domain projects, and isolate unfamiliar infrastructure in minimal experiments with focused performance tests.
Developer Growth Starts with Finishing the Work
Build professional trust by completing valuable work within a quality baseline, then refactor, learn, and prepare deliberately for the next step.
Why Manager and Processor Classes Are Refactoring Signals
Use vague class names as code-smell signals, then narrow responsibilities and right-size layers without denying necessary transitional design.
Swagger vs REST Docs: Choose API Documentation by Context
Compare Swagger and REST Docs by test enforcement, code intrusion, customization, and a pragmatic migration path for legacy APIs.
One Project, Many Deployables: Drawing Boundaries by Runtime Role
Separate public, admin, batch, and operations workloads into runnable applications without splitting the whole codebase into separate projects too early.
Track Database Changes with the Work That Ships Them
Collect database changes with the issue and PR that need them, test them in development, and hand off the final release set before code deployment.
Software Is Not Done Until It Is Deployed
Stale pull requests and delayed releases make changes harder to review, deploy, diagnose, and roll back. Keep the path to production short and observable.
Rebuild First, Migrate Second
Design a replacement system around the problems it must solve, then handle legacy data through explicit migration mappings and retirement conditions.
Put Logic Where Change Is Cheapest: Client vs. Server
Place display-only work near the UI, but centralize meaningful or changing values when multiple clients and shipped app versions make updates expensive.
Don't Distort Production Code Just to Make Tests Easier
Change production code when its behavior becomes clearer or legacy code needs a testing seam—not merely to expose values or methods that only tests use.
Modernize Legacy Systems Gradually—and Treat Caches as Operations
Choose legacy boundaries carefully, change them in small steps, and add a shared cache only after DB work and deployment failure modes are understood.
Git History Is a Team Asset, Not a Work Diary
Split work before polishing commits, shape pull requests for reviewers, and leave a history that helps the next engineer understand changes and recover a release.
Upgrade Dependencies Before the Gap Becomes a Project
Frequent, prioritized dependency upgrades keep change small, expose compatibility problems early, and prevent a maintained service from quietly accumulating debt.