Weekly Article Backlog

Weekly Article Backlog

This file is a working backlog for weekly blog posts. The goal is to keep enough ideas ready so publishing does not depend on inspiration appearing at the perfect time.

Weekly Cadence

  • Week 1: Automation, process, or AI-assisted workflows.
  • Week 2: Kubernetes, DevOps, platform engineering, or cloud tooling.
  • Week 3: Security, reliability, observability, or incident response.
  • Week 4: Career, communication, recruiting, or lessons learned.

Keep each article focused on one clear opinion. A good post should answer: what changed, why it matters, what people usually get wrong, and what a better approach looks like.

Article Ideas

  1. Why Automation Is Not Optional Anymore
  2. AI as a Junior Operator, Not a Senior Engineer
  3. The Difference Between Automation and Orchestration
  4. When Kubernetes Is Worth It, and When It Is Overkill
  5. What I Wish More People Understood About Infrastructure as Code
  6. Terraform Is Powerful, But State Is Where the Pain Lives
  7. Why Good Documentation Is an Engineering Tool
  8. Runbooks Are Not Bureaucracy
  9. The Hidden Cost of Tribal Knowledge
  10. How to Design Systems That Are Easier to Recover
  11. Why “It Works on My Machine” Still Exists
  12. The Importance of Idempotency in Automation
  13. CI/CD Is Not Just Deployment Automation
  14. GitOps: Great Idea, Often Poorly Explained
  15. What Argo CD Teaches You About Desired State
  16. Monitoring vs Observability: Why the Difference Matters
  17. The Alert Fatigue Problem
  18. How AI Can Help During Incidents
  19. Why Postmortems Should Not Be Blame Sessions
  20. Security Checks Should Be Automated Early
  21. The Problem With Manual Access Reviews
  22. Why Secrets Management Still Gets Ignored
  23. Backups Are Boring Until They Save You
  24. Disaster Recovery Plans Need Practice, Not Just Documents
  25. Why Small Teams Need Processes Too
  26. Process Is Not the Enemy of Speed
  27. How Bad Handoffs Break Engineering Teams
  28. The Difference Between Busy Work and Valuable Work
  29. Why Engineers Should Care About Business Context
  30. AI Will Not Fix a Broken Process
  31. The Danger of Automating Bad Workflows
  32. How to Decide What to Automate First
  33. The Human Side of Platform Engineering
  34. Why Internal Developer Experience Matters
  35. Good Tools Reduce Cognitive Load
  36. The Recruiter Problem From an Engineer’s Perspective
  37. How Candidates Can Set Better Boundaries
  38. What Makes a Good Technical Interview
  39. Lessons Learned From Working With Linux Systems
  40. What I Would Tell Someone Starting in DevOps Today
  41. Why Every Team Needs a Definition of Done
  42. The Difference Between Done and Deployed
  43. Why Rollbacks Should Be Designed Before Deployments
  44. The Best Automation Starts With a Boring Checklist
  45. How to Make Onboarding Less Dependent on Luck
  46. Why Every Production Change Needs a Recovery Path
  47. AI Coding Tools Need Constraints, Not Just Prompts
  48. How to Review AI-Generated Code Without Losing Trust
  49. The Case for Smaller Pull Requests
  50. Why TDD Matters Even More When Building With AI

Strong Starting Picks

  • AI Will Not Fix a Broken Process
  • GitOps: Great Idea, Often Poorly Explained
  • The Hidden Cost of Tribal Knowledge
  • How to Decide What to Automate First
  • Why TDD Matters Even More When Building With AI
  • AI Coding Tools Need Constraints, Not Just Prompts

Article Template

Use this shape when a topic feels too broad:

  1. Start with a direct opinion.
  2. Explain the problem in practical terms.
  3. Give one real technical example.
  4. Show the common mistake.
  5. Explain a better approach.
  6. End with a short takeaway.

AI-Assisted Writing Notes

  • Give the AI context about the blog voice: practical, opinionated, technical, and direct.
  • Ask for outlines before drafts when the topic is broad.
  • Prefer personal examples over generic industry claims.
  • Remove filler phrases like “in today’s fast-paced world” or “game changer.”
  • Keep the final article specific to infrastructure, DevOps, automation, security, or engineering work.
  • Ask the AI to challenge the argument before polishing it.
  • Make the final editing pass manually so the article sounds like an experienced engineer, not a brochure.

AI Build Configuration Tips

These notes are for coding with AI assistants, especially when iterating on applications, automation, infrastructure code, or documentation-driven tooling.

TDD Is Mandatory With AI

When building with AI, TDD is not a nice option. It is a must.

AI-assisted development can move quickly, but speed makes regressions easier to miss. During multiple iterations, a feature can break without anyone noticing until much later. Reverting after several rounds of changes often wastes more time than starting with a structured test-first approach.

Use tests as guardrails:

  • Write or update tests before asking AI to change behavior.
  • Keep tests focused on the expected user-visible outcome.
  • Run tests after every meaningful change.
  • Treat failing tests as the next task, not as noise.
  • Add regression tests whenever AI fixes a bug.
  • Avoid accepting large AI changes without a test that proves the important behavior still works.

Give AI Clear Boundaries

  • Define the goal and the non-goals before implementation.
  • Tell the AI which files, modules, or layers it is allowed to touch.
  • Ask for small, reviewable changes instead of broad rewrites.
  • Require the AI to preserve existing patterns unless there is a clear reason to change them.
  • Make acceptance criteria explicit before code is written.

Keep Iterations Small

  • Change one behavior at a time.
  • Run the test suite between iterations.
  • Commit working checkpoints before major refactors.
  • Avoid mixing feature work, formatting, and cleanup in one change.
  • Ask for a short implementation summary after each iteration.

Review AI Output Like Untrusted Code

  • Check edge cases manually.
  • Look for deleted behavior, not just added behavior.
  • Watch for fake abstractions that make the code harder to understand.
  • Confirm that errors, empty states, and permission failures still work.
  • Verify config examples, commands, and dependency versions.

Good Prompt Shape for Coding Tasks

Use this structure when asking AI to build or change something:

  1. Context: what the project does and where the relevant code lives.
  2. Goal: the exact behavior you want.
  3. Constraints: what must not change.
  4. Tests: what should prove the change works.
  5. Verification: commands that must pass before the task is done.

Example:

We are working in a Jekyll blog repo. Add a new post under _posts.
Do not change layouts, styles, or existing posts.
Use the existing front matter format.
After editing, check front matter parsing and run git diff --check.

Weekly Publishing Workflow

  1. Pick one topic from the backlog.
  2. Write a 5-7 bullet outline.
  3. Add one personal or practical example.
  4. Draft the article.
  5. Edit for clarity and remove generic wording.
  6. Check Markdown formatting.
  7. Commit and push to publish.