What Claude Code is, and what it is not.
Claude Code is agentic coding. It reads a codebase, plans changes, makes edits across files, runs commands, and reports back. The shift from copy-paste-into-chat is bigger than it sounds.
Agentic coding in plain English
In Chat, you ask, Claude answers, you paste the answer somewhere. In Code, Claude works inside your project. It reads files, edits files, runs the tests, fixes what it broke, and tells you what changed. You review. You approve. You ship.
For an AEC firm, that means the small internal tools that used to need a developer no longer do. The Excel macro the estimator has been meaning to clean up. The Bluebeam script that almost works. The data export from Procore that a Power Automate flow could clean up if anyone had two days. Claude Code can ship those in an afternoon.
Claude Code does not turn an operator into a developer. It turns an operator into someone who can ship a useful internal tool without hiring a developer for the small stuff. Know the difference.
When Code is the right surface
- The work touches real files, real code, or a real script. Not a memo, not a brief.
- The change spans more than one file or more than one step.
- You want a working artifact at the end, not advice.
Install and authenticate.
Ten minutes from zero to your first session. Two surfaces (desktop and CLI), one account.
The install
What Claude Code can touch
- Files in the folder you launched it in. Nothing outside.
- Commands in your shell, with your permission. Each one shown before it runs the first time.
- Network calls only when you tell it to. Claude Code is local-first.
- Sessions can start on one machine and continue on a phone via remote control. Useful for the PM who started a long job at the desk and walked to the jobsite.
Clean up a Bluebeam or Excel script.
Twenty minutes end-to-end on a small, real artifact. Bring a script you have been meaning to clean up. The point is to feel the loop.
The opening prompt
The edit loop
Once the assessment is in front of you, pick the smallest change that makes the script better. Have Claude Code make it. Run the script. Confirm. Commit. Repeat. Two hours later you have a cleaner version of the artifact and a five-line changelog you can hand to the next person.
Plan-then-Execute on a real pipeline.
The single pattern that keeps an agent honest on multi-step work. Twenty minutes worked on a Procore data-export pipeline.
The pattern
Worked: a Procore data-export pipeline
The firm exports Procore data into a CSV every Monday. Half the columns are wrong, dates are in two formats, and three subs are spelled three different ways. Plan-then-Execute walks Claude Code through the cleanup once. After that, the script runs every Monday on a schedule.
- Plan: identify the columns, the date formats, the alias problem. Stop.
- Execute step 1: a normalizer for dates. Show diff. Run on last week's CSV. Confirm.
- Execute step 2: a sub-name alias map. Show diff. Confirm.
- Execute step 3: the wrap-up script that runs the pipeline end to end on Monday morning.
Hand it off with /goal
Plan-then-Execute keeps Claude Code on a short leash, one approved step at a time. The complement, shipped in v2.1.139 in May 2026, is the /goal slash command. You state a finish line and walk away. Claude Code enters an autonomous agent mode and keeps working across turns until the condition is met.
A second, faster evaluator model reads each turn's transcript and judges whether the condition is satisfied. When it is, control returns to you. The evaluator only judges the transcript. It does not run tools itself.
Three AEC use cases
The patterns where Claude Code pays back fastest at an AEC firm.
One more pattern worth naming, then leaving alone. For codebase-wide audits, large migrations, or cross-checked research, the right 2026 pattern is dynamic workflows and multi-agent orchestration. Claude writes an orchestration script that fans out to many subagents in the background, then reconciles their work. Past the scope of this resource. POLR Development is where that work lives.
Hand off. Decide what is next.
The fifteen minutes that decide whether your firm should adopt Claude Code, hire someone who can, or contract the work out. Honest about all three.
Version control basics for non-developers
- Initialize a git repo in the folder. Even on your laptop, even if nobody else touches it. git init.
- Commit after every working change. git add . && git commit -m "what changed".
- Roll back with git checkout -- . when an experiment broke everything.
- Anthropic's security-guidance plugin reviews Claude's edits for vulnerabilities in the same session, so the diff you commit has already been pressure-tested.
Build, hire, or contract
Build it yourself when the tool is small, the firm has the time, and the tool is the firm's own process (nobody else can describe it as well). Hire someone when you have three or more tools like this in the next year. Contract it out when you want it shipped in four to six weeks with a fixed scope and you do not want the maintenance debt on the team.
POLR's Development service line is the third option. We pair with your team or do it standalone.
What to read next
- Getting Started with Claude Cowork: if the work is documents, not code, Cowork is the right surface.
- Getting Started with Claude Connectors and Plugins: when an integration exists, you do not need to write the script.