I've been writing code since my freshman year at UIT. I've shipped microservices in .NET, Go, Java, and Node.js. I've deployed Kubernetes clusters with Istio service meshes, built blockchain notarization platforms on Ethereum, trained ML models with TensorFlow, and led teams from 5 to 10 people across hackathons and production systems.

But the most significant shift in how I work didn't come from learning a new language or framework. It came from the day I started treating an AI as a persistent engineering partner.

This is the story of how Claude Code changed the way I build software — not on one project, but across everything I do.

It Started With a Problem of Scale

As a product-minded engineer, I don't have the luxury of staying in one lane. In any given week, I might be writing Go microservices for a carbon credit platform, debugging CloudFormation templates on AWS, reviewing a PR for a Next.js frontend, triaging Jira tickets, updating Confluence docs, and preparing a sprint plan — all while keeping production systems healthy.

The problem isn't skill. It's bandwidth. There are only so many context switches a human brain can handle before quality drops. I needed something that could hold context across a complex codebase while I focused on the decisions that actually matter.

Claude Code turned out to be that thing.

How I Actually Work With It

Most people use Claude Code for one-shot tasks — prompt, let it edit, review, done. My workflow is different. It's iterative and reactive. I kick off a task, test the result manually, come back with corrections, and keep pushing until it's right. Over 620 sessions and 1,610 hours, Claude Code isn't just a tool I use — it's a persistent engineering partner I collaborate with across every project I touch.

Infrastructure and Cloud Debugging

I work heavily with AWS — ECS, CloudFormation, DynamoDB, S3, Secrets Manager. When deployments break (and they always break), I keep a Claude Code session open and work through each issue in sequence. Claude reads the CloudFormation template, checks the error logs, identifies the misconfiguration, and suggests the fix — all in one continuous conversation.

In one session, we chained together fixes for IAM permissions, missing DynamoDB GSIs, secret ARN mismatches, and CORS misconfigurations. Five distinct issues diagnosed and resolved without switching between AWS console tabs and Stack Overflow. That kind of session used to take a full day. Now it takes a few hours.

Backend Systems Across Multiple Languages

My projects span .NET, Go, Java, Node.js, and Python — each with its own idioms, patterns, and tooling. Claude Code handles the polyglot context-switching better than I expected. When I'm working on my Go-based carbon credit platform (GreenLedger — 6 microservices with gRPC, Kafka, and Kubernetes), it writes idiomatic Go. When I switch to a NestJS backend, it follows the decorator patterns and module structure. When I'm in Python with FastAPI, it uses Pydantic properly.

The key is that Claude reads the existing codebase before generating anything. It matches the patterns already there — which is exactly what I want from a collaborator.

Kubernetes and DevOps

For my graduation thesis — a cloud-native e-commerce platform — I used Claude Code extensively for Kubernetes configurations, Helm charts, Istio service mesh setup, and the observability stack (Prometheus, Grafana, ELK). Writing YAML by hand for a 5-service microservices architecture with proper resource limits, health checks, HPA autoscaling, and network policies is tedious and error-prone. Claude handled the boilerplate while I focused on architecture decisions.

It also helped me set up CI/CD pipelines with vulnerability scanning — something I carried over to GreenLedger, where security-focused pipelines are critical for a platform dealing with carbon credits and financial data.

Hackathons and Rapid Prototyping

I won First Prize at IT Hackathon 2025 with a blockchain-based notarization platform built on Ethereum and Solidity. During the hackathon, speed is everything. Claude Code let me scaffold smart contract interactions, set up the React Native frontend, and wire Firebase auth — all while I focused on the core blockchain logic and team coordination across 10 developers.

For the Web3 HackFest (Top 30), same pattern: Claude handles the infrastructure and boilerplate, I handle the product thinking and architecture.

Security — Where Plugins and Skills Really Shine

Security is where Claude Code's plugin ecosystem clicks. Instead of relying on Claude's general knowledge to catch vulnerabilities, I plug in dedicated security tools that run real analysis:

• Aikido — An MCP plugin that runs SAST scans directly from Claude Code. It scans generated or modified files for vulnerabilities and exposed secrets in real time. After I edit code, Aikido catches what Claude's reasoning alone might miss — actual CVEs in dependencies (it flagged issues in nltk, Crawl4AI, and system libraries in my Docker images), hardcoded secrets, and injection patterns.
• Semgrep — Static analysis with custom rules. I run Semgrep through Claude Code to enforce security patterns across the codebase — things like ensuring all database queries use parameterized inputs, all URL fetches go through SSRF validation, and no secrets leak into logs. Claude reads the Semgrep output and fixes the flagged issues directly.
• gstack's /cso skill — Chief Security Officer mode. This is a full infrastructure-first security audit: secrets archaeology (scanning git history for leaked credentials), dependency supply chain analysis, CI/CD pipeline security review, and LLM/AI-specific attack surface assessment. One command kicks off a structured, multi-phase audit.

The workflow looks like this: I write or modify code with Claude Code, Aikido scans the changes automatically, Semgrep enforces rules across the repo, and /cso runs periodic deep audits. Claude doesn't just write the fixes — it understands the why. When I say "prevent SSRF," it blocks private IPs, loopback addresses, link-local ranges, and reserved IPs. When I say "escape user input in queries," it checks every query path, not just the one I pointed at.

This layered approach — AI-assisted coding plus automated security tooling plus structured audit skills — catches things that any single layer would miss alone.

Documentation and Project Management

Most engineers treat docs as an afterthought. I use Claude Code to audit and update Confluence documentation against the actual codebase, write PRDs from Jira data, create feasibility analyses, and keep knowledge bases current. It reads the code, reads the existing docs, flags what's outdated, and rewrites with current information. In a single session.

I also use it for sprint planning, release notes, and stakeholder communication — the product management side of my role that benefits just as much from AI assistance as the engineering side.

The Honest Part: Where It Goes Wrong

After 620 sessions, I know exactly where Claude Code struggles.

It over-engineers everything. Give it an open-ended request, and it builds a cathedral when you asked for a shed. I've learned to be explicit: "Fix ONLY this. Do not modify anything else."

It guesses wrong on the first try. About 370 of my 620 sessions had at least one wrong initial approach — wrong environment, wrong access pattern, wrong diagnosis. The fix: front-load your context. One sentence about which environment you're targeting saves three rounds of corrections.

It makes unrequested changes. I ask it to fix a button color, and it also "improves" the card opacity and refactors the component. The fix: ask it to explain its plan before editing. Diagnose first, then fix.

These aren't dealbreakers. They're the cost of working with a powerful but imperfect tool. And honestly, learning to communicate clearly with Claude has made me a better communicator with my team too.

Tools That Multiply the Multiplier

MCP Integrations

I use the Atlassian MCP for Jira/Confluence, Aikido for security scanning, and Context7 for library documentation. These integrations turn Claude Code from a code generator into a workflow automation tool that connects to the systems I actually use daily.

gstack Skills

My most-used Claude Code extension. /investigate for production bugs (enforces root cause analysis before any fix), /qa for end-to-end testing, /ship for the full PR workflow, /review for pre-landing diff checks, /cso for security audits. Each skill encodes a complete workflow with phases and guardrails — no need to re-explain the same process every session.

LLM Wiki — My Second Brain

This one goes beyond any single project. Inspired by Andrej Karpathy's LLM Wiki concept, I maintain a persistent markdown knowledge base that Claude Code reads, writes, and maintains for me.

The architecture is simple: a folder of raw sources (articles, papers, notes), a wiki layer of LLM-generated markdown pages (summaries, entity pages, cross-references), and a schema file that tells Claude how to maintain it all. I use Obsidian as the reader and Claude Code as the writer.

When I learn something new — a Kubernetes pattern, a Go concurrency trick, a CloudFormation gotcha, a blockchain optimization — I drop the source into the wiki and Claude processes it: writes a summary, updates the index, cross-references with existing pages, flags contradictions. A single source might touch 10-15 wiki pages.

I use this across everything — infrastructure patterns, security practices, framework deep-dives, debugging techniques, product management frameworks. It's my second brain, except the LLM does all the maintenance work that would make me abandon a traditional wiki within a month.

What I've Learned

After 1,610 hours of working with Claude Code across microservices, infrastructure, frontends, blockchain, ML, documentation, and project management, here's what I believe:

Claude Code isn't a replacement for engineering judgment. It's a multiplier. It handles the breadth — reading logs, searching codebases, generating boilerplate, running commands, maintaining documentation — while I handle the depth: architecture decisions, product thinking, trade-off analysis, and steering toward the right solution.

The friction is part of the process. Every correction I make teaches me to communicate better. Clear constraints, explicit scope, and diagnosis before action aren't just AI prompting techniques. They're good engineering practices.

AI proficiency is becoming a core engineering skill. Just like knowing Git, knowing Docker, knowing how to write tests — knowing how to effectively collaborate with an AI coding partner is now a real competitive advantage. Not because it writes perfect code, but because it lets you operate across a surface area that would be impossible alone.

I'm still early in this journey. There's so much more to explore — autonomous test-driven debugging, parallel sub-agents for deployment validation, deeper LLM Wiki workflows. But even now, I can't imagine going back to working without it.

If you want to chat about AI-assisted development workflows, find me on GitHub or LinkedIn. I'm always building, always learning.