Claude TELUS Training - Pre-course Survey

Identity

Called an LLM API from code (any provider: OpenAI, Google, Bedrock, Azure, local models)

Built and shipped an app, service, or pipeline that calls an LLM API

Built an agent with a framework or SDK (LangChain, LangGraph, CrewAI, OpenAI Agents SDK, or similar)

Built retrieval / RAG: embeddings, a vector store, chunking, retrieval into prompts

Written evals or automated tests for LLM output quality

Used model-driven computer use or browser automation (a model operating a UI)

Use an AI coding assistant (Copilot, Cursor, or similar) as a daily habit with your work

Fine-tuned or adapted a model (full fine-tune, LoRA, or similar)

Local or open-source models (Ollama, vLLM, or similar)

Chosen a smaller or faster model, or trimmed input, to manage cost, rate limits, or latency on a big job

Restructured a long input around the context window: split it up, or moved the key facts to the top

Written or edited a system prompt or persistent instruction to set role, constraints, or output format

Worked with files, not just text: had the model read or produce documents, spreadsheets, images, or PDFs

Improved an answer by changing what context you provided (adding or removing background), not just rewording the question

Grounded answers in specific sources (uploads, project knowledge, a connected tool) instead of the model's general knowledge

Run a Deep Research query on a real question and used the cited result in your work

Created an artifact (a document, table, chart, or small app) and iterated on it across turns

Set up a Project with persistent instructions or uploaded knowledge and returned to it across sessions

Picked or switched Claude models deliberately for cost or speed (a faster model for routine work, a stronger one for hard problems)

Turned extended thinking on for hard problems and off for simple ones

Habitually write structured prompts (role, criteria, examples, output format) and rework them when the output misses

Handed Claude a multi-step task (for example in Cowork or Claude Code) and let it run to completion

Regularly use existing Skills instead of re-prompting from scratch

Created a Skill of your own (a SKILL.md or equivalent packaged capability)

Maintain a memory or instruction file (a CLAUDE.md or project memory) scoped to you or a project

Connected Claude to an external tool or data source via a connector or MCP server and used it in real work

Designed a review or approval checkpoint into agent work (human-in-the-loop)

Configured Claude Code for a real project: CLAUDE.md hierarchy, path-scoped rules, custom slash commands or Skills

Built a custom MCP server and wired it into a workflow

Run and managed agentic loops: understood stop conditions and drove iterative refinement with tests, examples, or back-and-forth

Deliberately managed context on long tasks: trimmed tool output, persisted state to scratch files, kept key facts alive

Had Claude return structured output against a defined JSON schema (for example via tool use)

Shipped a Claude-powered automation that other people rely on

Driven Claude computer use or browser automation on a real task (Claude operating a UI)

Designed multi-agent orchestration: a coordinator dispatching subagents, context isolation between them, parallel runs

Used Agent SDK hooks to enforce workflow steps instead of relying on prompts alone

Designed tool interfaces and error handling for an agent: descriptions, retryable versus terminal errors, tool choice strategy

Used the Claude API beyond single calls: the Batch API with a rationale, prompt caching, streaming, or validation-with-retry on structured output

Built evals with human-review checkpoints and provenance tracking across sources

Made system-design tradeoff calls for Claude in pipelines: headless runs, machine-readable output, cost and latency budgets