How I Use Claude Code to Build Software at PiCode

Introduction

I've been using Claude Code — Anthropic's CLI tool for coding — as part of my daily workflow at PiCode Solutions. It's not a novelty anymore. It's part of how I ship software.

This post covers the specific ways I use it across development, cloud infrastructure, and day-to-day problem solving. No hype — just what actually works.

Scaffolding New Features

When I'm starting a new feature, Claude Code is usually the first thing I reach for. I describe what I need — a new API endpoint, a React component, a database migration — and it generates the scaffolding in the context of my actual codebase.

What makes this different from copy-pasting snippets is context. Claude Code reads my project structure, understands the patterns I'm already using, and generates code that fits. It picks up on things like:

The component conventions in my Next.js app
How I structure my .NET API controllers and services
Existing Tailwind utility classes and design tokens

This alone saves a significant amount of time on every new feature. I spend less time on boilerplate and more time on the logic that matters.

Azure Subscription Management

A big part of running PiCode is managing Azure infrastructure — and that means staying on top of resource groups, app services, networking configs, and cost.

I use Claude Code to help me:

Review and adjust Azure resource configurations — generating ARM templates, Bicep files, or CLI commands to provision and update resources
Analyze cost reports — I feed in cost breakdowns and ask Claude Code to identify underutilized resources, suggest reserved instance opportunities, or flag services that could be downgraded
Automate routine subscription tasks — instead of clicking through the Azure Portal, I describe what I need and get the exact az cli commands to run

This is especially useful when managing multiple client environments. Instead of context-switching through portals, I stay in the terminal and move fast.

Implementing Azure Architecture Improvements

Beyond day-to-day management, Claude Code helps me think through and execute architecture changes:

Migrating app services between pricing tiers or regions
Setting up auto-scaling rules based on actual traffic patterns
Configuring Application Insights and diagnostic settings for better observability
Designing networking changes — VNet integration, private endpoints, and NSG rules

Having an AI that can reason about tradeoffs while also generating the implementation code means I can evaluate options and ship changes in the same session.

Cost Cutting Measures

Cloud cost optimization is an ongoing effort, not a one-time project. Claude Code has become my go-to for this:

Right-sizing resources — analyzing current usage and recommending appropriate SKUs
Identifying idle resources — finding app service plans, databases, or storage accounts that are provisioned but barely used
Reserved instance planning — calculating break-even points for committing to reservations vs. pay-as-you-go
Optimizing App Service Plans — consolidating apps where possible, moving to cheaper tiers where performance allows

The compound effect of small optimizations across multiple Azure subscriptions adds up quickly.

App Service Debugging

When something breaks in production, speed matters. Claude Code is incredibly useful for debugging Azure App Services:

I paste in error logs or Application Insights traces, and it identifies the root cause faster than I'd find it manually
It helps me craft Kusto queries for Log Analytics when I need to dig deeper
For deployment issues, it can analyze deployment logs and spot configuration mismatches
When performance degrades, it helps me interpret metrics and pinpoint bottlenecks

The ability to go from "something is wrong" to "here's the fix" in minutes instead of hours is a genuine productivity multiplier.

Learning What's Possible

One of the underrated benefits of working with Claude Code is the learning curve it flattens. Azure is massive — there are services and features I'd never explore on my own simply because I didn't know they existed or didn't have time to read through the documentation.

Claude Code surfaces options I wouldn't have considered:

"Did you know you can use Azure Front Door for this instead of a standalone CDN?"
"This workload would benefit from Flex Consumption Functions instead of the Premium plan"
"You can use deployment slots to achieve zero-downtime deployments here"

It's like pair programming with someone who has read every page of the Azure documentation. I still make the decisions, but I make better-informed ones.

How It Fits Into My Process

Claude Code isn't a replacement for understanding what I'm building. It's a force multiplier. Here's how it fits into a typical day:

Morning — I review what needs to be done (thanks, EOS rocks) and use Claude Code to scaffold any new feature work
Midday — Active development, using Claude Code for code generation, debugging, and architecture questions
Afternoon — Infrastructure work, cost reviews, and deployment tasks — often driven through Claude Code in the terminal

The key is that it stays in my workflow. I don't switch to a browser, paste code into a chat window, and copy answers back. Everything happens where I'm already working.

Conclusion

Claude Code has changed how I work at PiCode — not by replacing the thinking, but by accelerating the execution. I ship features faster, manage Azure infrastructure more confidently, and catch cost inefficiencies I would have missed.

If you're a developer or a small team lead managing both code and cloud, it's worth integrating into your workflow. Start with what slows you down most and let it handle the grunt work.