Practical Learnings From Using Claude Code for Everything

---

I've used Claude Code since last November, replacing my previous copilot as my main coding assistant. Over the past 3 months, Claude Code itself has improved a lot — automatic planning mode, multi-agent support, Opus 4.6, etc. It went from a chat tool I ask questions to, to a persistent engineering system that runs across multiple remote machines, improves itself, and manages my projects.

3 Principles

Before the practices, here's my thinking behind them:

1. Your prompt is your intelligence. If not all of it, at least most. Every time you craft a good instruction, debug a tricky issue, or figure out the right way to ask Claude — that's valuable. If you don't save it, you'll repeat the same discovery next week on a different machine. Persist your prompts. Improve them over time. Treat them like code.

2. Slow is fast. It's tempting to just start chatting and let Claude figure it out. But hand-writing a design doc, a logic flow, or even just a bullet list of what you want — that upfront investment prevents the back-and-forth loops where you go crazy fixing the same issue three times. The same applies to building your Claude setup: spending time on CLAUDE.md and skill architecture pays off every single session.

3. Proactive beats passive. It's obvious now how to use Claude Code reactively — ask a question, write a step-by-step plan, and spawn multi-agent to do it. But by the time you realize you could have asked Claude for help, it's often already late. Set up proactive flows: let Claude monitor things, analyze your work, ping you. Don't wait to be asked.

Practice 1: Save Everything (The Foundation)

Challenge: If you use ephemeral cloud instances or multiple remote machines, prompt history, settings, custom skills — all lost when a machine spins down.

Solution: Mount cloud storage (Google Drive, Dropbox, etc.) as the single source of truth.

• Save session history to ~/cloud-drive/claude-history/<hostname>/
• Cron scripts, project docs, knowledge files — all in cloud storage
• One setup script bootstraps any new machine in minutes

~/cloud-drive/
├── claude-config/    # CLAUDE.md, settings.json, skills
├── claude-history/   # Session history from all machines
├── crontab/          # Cron scripts synced across all machines
├── knowledge/        # Project context docs
└── worklog/          # Project tracking

This is the foundation. Everything else builds on top of having your prompts, configs, and knowledge persisted and synced.

Practice 2: Let Claude Study Itself (Self-Improvement Loop)

Challenge: You make the same mistakes with Claude repeatedly. You discover preferences ("don't use histograms, use scalars") but forget to codify them. You solve a painful infrastructure issue and the knowledge evaporates.

Solution: Since Practice 1 saves all your prompt history across machines, you can now have Claude analyze its own usage.

A nightly cron job gathers the last 2 days of prompts from all machines and feeds them to Claude for analysis. It specifically looks for:

• Efficiency issues — back-and-forth loops, repeated debugging patterns
• Preference signals — phrases like "remember this", "I told you", "don't do X"
• Frustration markers — ALL CAPS, "!!!", "again"
• Quick wins — actionable recommendations

Detected patterns get codified into CLAUDE.md, skill files, or project context — creating a self-improvement flywheel. My CLAUDE.md is now 11KB+ of accumulated "dark knowledge": ML-specific preferences, commit safety rules, CI debugging workflows, infrastructure tribal knowledge — all captured from past painful experiences so they never repeat.

Practice 3: Proactive Workflows (Don't Wait to Be Asked)

Challenge: Claude Code sits idle until you open a terminal and type something. Meanwhile, docs change, GPU jobs fail, and opportunities to act pass by.

Solution: Set up cron-based workflows where Claude runs without you and pings you when something needs attention.

Schedule	What It Does
9am daily	Fetches tracked Google Docs, compares with last summary, pings you if anything changed
9pm daily	Self-improvement analysis (Practice 2)
Hourly (9am–1am)	Checks GPU quotas across clusters, alerts when rebalancing opportunities exist

Practice 4: T-Shape Skills (Horizontal + Vertical)

Challenge: You work on multiple projects. Each has different code, different workflows, different milestones. But many capabilities are shared — project tracking, meeting prep, job debugging. How do you avoid rebuilding the same thing per project?

Solution: Build a T-shape skill architecture. Horizontal skills work across all projects. Vertical skills add project-specific context and route to the right horizontal tool. You can think of the vertical layer as a project-specific CLAUDE.md.

For example, for one of my ML projects, the vertical skill knows the working directory, yesterday's progress, and next milestones. When I say "check my training job," it routes to the job debugger with the right context. When I say "what's next," it pulls from the project tracker. The horizontal skills don't need to know about the specific project — the vertical skill bridges the gap.

Practice 5: Stand on Others' Shoulders (Skill Ecosystem)

Challenge: You're not the only one solving these problems. Other engineers have distilled their knowledge into reusable Claude skills. But you don't know what exists, and you don't know what you're missing.

Solution: Proactively discover and adopt skills from your team or organization's ecosystem.

If your company has a skill catalog, treat it like a package registry — browse it regularly. But even better, automate the discovery. I built a "skill radar" that helps with this:

• Daily digest — set it up as a cron job, and every morning you get a notification with personalized skill recommendations based on your recent work
• History-aware — it analyzes your past prompt history to understand what domains you work in, what tools you use, what problems you hit, then matches you with relevant skills
• Deep recommendation — beyond keyword matching, it uses Claude as a sub-agent to read each skill's documentation and assess relevance to your workflow

For example, it might notice you're debugging GPU training jobs frequently and suggest a specialized job debugger, or see you're running lots of build-system tests and recommend a test-driven development skill.

The vision: skills become a digital twin of your engineering team's collective knowledge. Every time someone codifies their debugging workflow, their CI tricks, their operational knowledge into a skill, everyone benefits. And with discovery running automatically, the right skills find you — you don't have to search.

Practice 6: Small Tricks That Add Up

Notification hooks — Claude always asks for permissions, and after an hour when you want results, you realize it's been waiting. Set up hooks so it sends you a push notification whenever it needs approval or is idle. Fire and forget, get notified when it needs you. Combined with Practice 1 (saved history), you can accumulate your own auto-approve patterns from the daily self-improvement suggestions — gradually teaching Claude what's safe to do without asking.

Mobile access — If you can set up a way to interact with Claude Code from your phone (via a chat bridge or web interface), you can kick off tasks, check status, and approve permissions while in meetings or away from your desk. Teammates can watch in real-time and even suggest prompts.

Reserve a permanent machine as your hub — Most of the practices above (cron jobs, self-improvement analysis, skill radar, mobile access) need a machine that's always on. Ephemeral instances expire and take everything with them. Reserve a cheap CPU instance — it doesn't need a GPU — and use it as your always-on hub. Mount your cloud storage, install your cron jobs, run your chat bridge. It becomes the brain that ties everything together while your GPU machines come and go.