Один из создателей Claude Code выдаёт базу. Борис Чёрный из Антропик

Technological concepts / product features (Cloud Code / “quadcode” = code-agent AI assistant)

What Cloud Code is

Cloud Code is an AI assistant for software engineering that works as an agent to build and fix code in one go—including tasks like:

• editing functions
• modifying files
• applying bug fixes

It’s designed to go beyond earlier coding assistants that mainly executed multiple lines at a time.

Universal integration / workflow compatibility

Cloud Code is presented as tool-agnostic, designed to work across different developer setups without changing the engineer’s workflow:

• Works with common developer environments without workflow changes, including:
  • Visual Studio Code / other coding IDEs
  • terminals
• Works both locally and in remote environments
• Compatible with “any environment” by integrating across whatever setup you use

Setup & onboarding guidance (practical tutorial elements)

Users are encouraged to install/configure Cloud Code beforehand, with recommended first-launch steps such as:

• Run terminal setup
• Use Shift + Enter for new lines
• Select light/dark theme
• Install a GitHub app using a terminal command
  • enables mentioning Cloud Code in issues/PRs
• Configure available tools so users don’t need to type them manually each time
• On Mac:
  • enable system dictation
  • use it to speak commands to Cloud Code

Recommended starting point

For new users:

• Start with the “QA codebase”
• Ask questions about it first, before immediately editing or using more complex tooling This helps teach effective prompting and distinguishes what requires human action vs. what Cloud Code can do autonomously.

---

Codebase Q&A behavior (analysis + “how it answers”)

More than text search

Cloud Code can look for:

• examples
• usage patterns of classes/functions

—not just keyword matches.

Uses commit/history understanding

For questions like:

“Why does this function have 15 weirdly named arguments?”

Cloud Code may inspect:

• Git history
• JIT/JID (as referenced in subtitles)

…to determine how/when arguments were added and by whom.

Uses GitHub context via web requests

Cloud Code can retrieve:

• GitHub issue context

It’s also used in recurring workflows (e.g., weekly meeting summaries derived from logs).

---

Privacy / architecture claims

The speaker emphasizes that Cloud Code:

• does not index code
• does not maintain a remote database of the user’s code
• does not train generative models based on user code

Result: users can start quickly without “indexing” steps or long waits.

---

Agent tool orchestration (editing + automation)

Small set of tools, composed automatically

Tools (as described) include:

• edit files
• run shell (sh) commands
• search files

Cloud Code automatically decides which tools to use and combines them in the right order.

Planning mode (recommended)

The speaker recommends:

• asking Cloud Code to plan before coding
• requesting approval before executing edits

This reduces the chance of large, misaligned implementations.

Git automation example

With commands like “think/commit/push,” Cloud Code can:

• create branches
• commit
• push
• generate a pull request

It does this by using the repository’s history/logs to format commits correctly.

---

Team workflows via “tools” and “verification loops”

Two tool categories

Cloud Code distinguishes between:

• Package tools / CLI-like tools (e.g., custom commands such as “Barley”)
• M(A)P tools / repo-specific tools (configured per codebase)

Verification to improve output

If Cloud Code can verify (e.g., unit tests, integration tests, screenshot tests, simulator runs), it can:

• repeat actions
• iterate toward correctness

Core idea: provide verification mechanisms and let the agent loop until results are confirmed.

---

Context configuration (“cloud.md”, slash commands, hierarchical settings)

Key mechanism: providing context via MD files

• Place a special cloud.md file in the project root to load at the start of each session
• Additional cloud.md files can live in subfolders and load on demand
• A company-level context can be placed in a company root for shared policies
• Guidance: keep context short to avoid wasting context-window space

Loading context via commands

• Slash commands can trigger workflows
  • example described: GitHub issue flagging via GitHub Actions
• Referenced files/folders can be included to expand context

Hint enhancer

A method was mentioned for building context tailored to:

• who it’s for
• how often it loads
• whether it’s shared

Hierarchical configuration layers

Settings can be scoped across layers such as:

• global / corporate
• project
• user
• team
• permissions

Corporate policy examples include:

• auto-approving approved commands (e.g., test commands for all employees)
• locking down dangerous/forbidden URLs
• managing prompts/install prompts related to “map servers”

---

“Memory / warehouse” management

The system references:

• “memory”
• a workflow where users can inspect loaded files and adjust which “memory targets” are used by a “remember” action

Mentioned specifics:

• using a pound sign (#) to save notes into chosen memory files

---

Command/terminal shortcuts (developer productivity tips)

• Automatic commit mode: Shift + T Commits automatically; the user still confirms commands; can revert later via console.

• Teach Cloud Code what to remember: $ + instruction Adds guidance to the code’s memory / cloud.md-style context.

• Run local command with context: type sh with an exclamation (press the exclamation point) Runs locally and includes it in context for next runs.

• Stop agent safely: Escape Stops without crashing the session.

• Resume sessions: a “resume function” after finishing.

• View what Claude/agent sees: Ctrl + R Displays more outputs.

---

“Deck / Dec” CLI layer (command-line interface)

The speaker mentions a Cloud Code “deck” / Dec tool inside Claude environments.

CLI features include:

• setting hints
• allowing/limiting tools (including batch command restrictions)
• choosing output formatting (e.g., streaming variants)

It’s framed as a “super useful Unix-like” utility for development/processing pipelines, including:

• data transfer between storage/buckets and the model.

---

Multimodal capability (images)

Cloud Code is described as fully multimodal, supporting:

• drag-and-drop an image
• specifying an image path
• copy/paste an image

Example use case:

• mock up a UI/layout by sending an image and asking it to implement.

---

Q&A highlights: safety, multimodality, CLI choice, ML/automation usage

Safety of shell/commands (hardest part)

Because shell commands can change system state unexpectedly, the approach includes:

• treating some commands as read-only
• using static analysis to determine which commands can be safely combined
• applying a multi-level permissions system to grant/deny blocking commands depending on backend type

Why CLI tool rather than UI

The reasoning provided:

• terminal is a common denominator across many dev setups/editors
• the belief models will improve quickly, making UI less relevant
• therefore, avoid heavy investment in UI that may not last

How much they use it for ML/automation

Claims include:

• Cloud Code is used daily by engineers and researchers
• estimate: ~80% of Anthropic tech staff use Code Quad every day
• researchers use it to edit and run programs

Implementation difficulty answer

Emphasized difficulty areas include:

• ensuring shell safety and permissions
• handling different backend/container setups (not everyone runs in the same container)

---

Main speaker / sources

• Boris Cherny (Boris Чёрный) — technical employee at Anthropic, creator of Claude Code / Cloud Code (as stated in subtitles).