Software Development in the Age of AI

After nearly two decades building software systems, from data centers to distributed cloud-native stacks, it's clear that we're entering a profoundly different era. The rate of technological acceleration, especially with the rise of generative AI, is unlike anything we've experienced before. It’s no longer feasible to deeply grok every layer of the stack or fully internalize the legacy behind every abstraction.

And that’s not a problem. It’s a paradigm shift.

Mastery in this environment isn’t about memorization or isolated genius. It’s about process, iteration, humility, and collaboration. Today, I treat mastery as a community endeavor. It is a living body of work shaped by human mentorship, machine assistance, and open documentation. I advocate for development practices that welcome contributions from both humans and AI. These contributions come in the form of code, comments, case studies, and corrections.

AI Is a Collaborator, Not a Replacement for Judgment

AI has become a first-class citizen in my daily development workflow. From rapid prototyping to test generation and documentation, tools like ChatGPT, Claude, and Copilot augment the pace and breadth of what’s possible. But it’s important to understand their limitations. AI tools are not infallible. They’re fast but often shallow. They’re confident but frequently incorrect.

This overconfidence is why software built with AI requires even more rigorous review. Testing frameworks, pull request reviews, and strong CI/CD enforcement are essential. In fact, they are non-negotiable. Your review process is the last line of defense against blindly shipping plausible but wrong code.

Scientific Software Development

My approach to development borrows heavily from the scientific method. This is a pattern of thinking that predates software by centuries and maps beautifully onto our craft:

1. Make an observation.
2. Ask a question.
3. Form a testable hypothesis.
4. Make a prediction.
5. Run an experiment.
6. Iterate based on results.

Test-Driven Development (TDD) is the software analog. Start with a failing test. Make it pass. Refactor. Repeat. In AI-augmented workflows, I still follow this red-green-refactor cycle, but I ask the AI to participate in my process. I use it to suggest test cases, generate edge scenarios, or propose hypotheses, but I do not delegate my judgment.

Shortcuts are tempting. AI tools will happily fake the implementation or overuse mocks. But your job as a developer is to maintain fidelity to the problem you are solving and to build feedback loops that reject false positives.

Especially in startup environments or lean delivery teams, this methodical test-driven approach, amplified by AI, lets us validate ideas faster and more reliably. Whether generating Mermaid diagrams, functional specs, or full test harnesses, AI is now an embedded part of my early-stage R&D loop.

A Minimalist, Scriptable Toolbox

Working in the cloud means working on other people’s servers. As such, my development tools must be portable, reproducible, and infrastructure-agnostic. I optimize for tools that meet the following criteria:

• Install via native package managers.
• Can be scripted end-to-end.
• Sync configuration via Git.
• Do not require GUIs.
• Work over SSH or headless environments.

This has led me to favor terminal-native tools such as neovim, tmux, and make. They are resilient, easy to configure, and increasingly well-supported by AI assistants. AI understands CLI inputs far more reliably than GUI operations, and the reproducibility of terminal workflows lends itself well to automation and collaboration.

Secrets and Security

One area that demands extra attention in the AI era is secrets management. Too often, I see developers (and AI agents) inadvertently check sensitive credentials into .env files or commit history. These practices are relics of a simpler era and are no longer acceptable.

I use AWS Secrets Manager and HashiCorp Vault to keep secrets out of source control and out of reach of AI assistants. For automation, GitHub Actions paired with these vault tools lets me maintain secure, ephemeral workflows without manual secrets handling.

Environment Consistency

Tooling sprawl is a real concern. I haven’t yet found a perfect answer for syncing dev environments across machines and teammates. Right now, I use GitHub templates and dotfiles stored in private repositories to encode my personal philosophy on structure, security, and scaffolding.

That said, this area is still evolving. The pace of AI-driven tool development makes this a moving target, and that’s okay. Flexibility is part of the deal.

Essential Tools

Editors and Terminal

• neovim: Extensible, scriptable, and AI-friendly code editor
• tmux: Terminal multiplexer for multi-pane productivity

Code Infrastructure

• make: Centralized build and task runner across environments
• Formatters and linters such as biome, and clippy with CI enforcement
• Shared CI/CD pipelines using GitHub Actions, CircleCI, or similar

Version Control

• git: The standard for version control
• gh CLI: GitHub command-line interface for automation and workflows

Docs and Data Retrieval

• markdown
• pandoc: Convert between document formats
• curl and wget: HTTP tools for remote data retrieval
• lynx and w3m: Text-based web browsers for minimal interfaces

AI Tools

Each AI assistant brings something different to the table:

• Claude excels at writing and high-level reasoning and integrates well with Neovim.
• Copilot offers solid code completion and inline support.
• ChatGPT helps with planning, architecture reviews, documentation, and research.

I use these tools at different stages of the software development lifecycle and always validate their output before moving forward.

AI has also influenced how I manage projects. I now prefer using GitHub Issues and Pull Requests for project management. These primitives are accessible to AI agents, making it possible for them to automate task creation and pull request generation directly through the GitHub CLI.

Closing Thoughts

The fundamentals of software development still matter. What’s changed is the velocity of iteration and the types of collaborators involved in the process.

Remember the core principles:

• Write modular, testable code.
• Keep secrets secure and isolated.
• Use reproducible and transparent tooling.
• Enforce high-quality review processes.
• Document everything.

AI does not replace the craft of software development. It reframes how we practice it.

This document, much like my development approach, will continue to evolve. The tools will mature, the problems will grow in complexity, and the contributors, both human and machine, will keep getting smarter.