Chapter 4: Maximizing productivity with skills and schedules
This introduction explains why repeated prompting becomes tedious and presents skills as reusable, adaptable workflows for Claude.
After this chapter you will be able to
- Reusable and adaptable skills. Describe a skill as a way to codify and invoke a repeatable workflow, and explain how it differs from a static function.
- Skill structure and context. Describe what a skill contains and how its instructions guide Claude.
- File Skills and Tools. Explain how built-in file skills divide work between Claude and tools, using the Word skill as an example.
- Stakeholder pack workflow. Describe how to ask Cowork to turn project design documents into a stakeholder document and an estimated build-phase spreadsheet.
- Automatic skill selection. Explain how Claude selected the document and spreadsheet skills in the exercise and where their loading was visible.
- Decision records through custom skills. Explain why a team might use a custom skill to produce an Architecture Decision Record (ADR), and what information the ADR preserves.
- ADR skill creation request. Describe how to ask Claude in a Cowork project to create an adr-writer skill, including the decision supplied by the user and the ADR file the skill should produce.
- Staged skill loading. Trace when Claude loads a skill’s description, full instructions, and any reference files, and explain why descriptions must be concise and informative.
- Recording a decision with a skill. Describe how to ask the custom skill to record a change of direction as an Architecture Decision Record (ADR), and what Claude produced in the example.
- Small and focused skill design. Justify keeping a skill limited to one clearly defined job rather than bundling tangential decision-related tasks.
- Consistent outputs from skills. Explain how a custom skill makes repeated outputs more consistent and reduces effort compared with nonspecific requests in separate chats.
- Portable skills and team conventions. Describe how installed and repository-stored skills are available to different users, and how a team can share an agreed ADR convention.
- Scheduled task operation. Explain how a scheduled task differs from opening a live artifact and what must be running for the schedule to trigger.
- Task output and confirmation. Describe how a connected Slack channel can provide a destination for scheduled-task output or confirmation.
- Daily repo digest schedule. Describe a schedule that checks every branch for commits from the previous day at 05:00 and sends a summary to a Slack channel, including when there was no activity.
- Unattended automation safety boundary. Justify keeping pre-approved schedules to safe reading and drafting rather than potentially destructive actions that need your verification.
- Independent runs and external state. Explain why each schedule run needs an external file for information it must carry forward, rather than updating its own schedule skill.
- Plugin packaging and sharing. Explain why plugins are useful when sharing multiple custom skills, and describe how a plugin and marketplace repository are organized.
- Plugin installation sequence. Describe how to add a repository marketplace in Claude Desktop, install its GitHub workflow plugin, and view the skills it provides.
- Third-party plugin safety. Explain why a public repository marketplace warrants caution and how Claude can help inspect a skills repository before use.
- Issue skill execution paths. Trace what happens when the create-issue skill is used for the scratchpad repository, including its GitHub CLI check and Desktop fallback.
- Choosing project skills. Explain when an individual skill is sufficient and why keeping it in a project repository is useful. Describe where project-focused skills typically run.
- Compact skill instructions. Explain why skill instructions should stay short and how to handle supporting information or pure automation.
- Automation benefits and costs. Explain the productivity tradeoff of handing work to skills and scheduled tasks, including why skills need not be as exhaustive as scripts.
- Platform version baseline. Describe how to identify the project’s platform-level technologies from its design docs and record their current stable versions in an agent-friendly document.
- Update notification skill. Explain how the skill uses the version list to find new releases, notify Slack, and record what it has already reported.
- Notification-only upgrade control. Explain why the scheduled automation reports release and security information but leaves upgrade decisions to the project owner.
What it builds on
- Tokens and context windows (chapter 1) · The idea that information can be included in Claude’s context.
- Projects: Organizing chats, tasks, and data (chapter 3) · Organizing project chats and data in Cowork
- Live artifacts and connectors (chapter 3) · The example of a live artifact connected to Gmail provides a contrast.
- Accessing external systems with connectors (chapter 3) · Connecting Claude to an external system provides context for the Slack example.
- Structured and unstructured data (chapter 2) · Working with structured and unstructured project information.
Section by section
Introduction
This introduction explains why repeated prompting becomes tedious and presents skills as reusable, adaptable workflows for Claude.
- Repeated prompting across sessions: Explain why doing the same kind of work with Claude can require repeated effort, even after a successful conversation.
Why it matters: This is the recurring effort that skills are meant to reduce. - Reusable and adaptable skills: Describe a skill as a way to codify and invoke a repeatable workflow, and explain how it differs from a static function.
Why it matters: A skill lets you reuse a workflow without repeatedly rebuilding its instructions.
Key terms: session, prompts, skill, workflow, reusable function, on demand, regular schedule
4.1 The skills behind the deliverables
This section explains what skills contain, how Claude uses them, and how built-in skills support file creation.
- Skill structure and context: Describe what a skill contains and how its instructions guide Claude.
Why it matters: This explains how a reusable set of instructions becomes guidance Claude can follow. - File Skills and Tools: Explain how built-in file skills divide work between Claude and tools, using the Word skill as an example.
Why it matters: This distinction helps explain how Claude produces usable files without manually writing their internal structure. - Skill invocation choices: Distinguish explicitly requesting a skill from Claude invoking one automatically.
Why it matters: You can request a particular skill without needing to name one every time.
Key terms: skill, SKILL.md, context, built-in skills, Word .docx, tools, invoke
4.2 Try it now — produce a stakeholder project pack
The exercise uses Cowork to turn project design documents into a stakeholder pack and shows how Claude selects relevant skills.
- Stakeholder pack workflow: Describe how to ask Cowork to turn project design documents into a stakeholder document and an estimated build-phase spreadsheet.
Why it matters: This gives you a practical way to turn technical designs into materials suited to stakeholders. - Automatic skill selection: Explain how Claude selected the document and spreadsheet skills in the exercise and where their loading was visible.
Why it matters: You can recognize when Claude has brought relevant capabilities into a task without being explicitly told which skills to use. - Custom skill candidates: Distinguish the role of built-in file-format skills from the kinds of repeated work that are candidates for custom skills.
Why it matters: Recognizing repetitive, difficult-to-script work helps you identify where a custom skill could streamline your workflow.
Key terms: Cowork project, design documents, stakeholder summaries, skills, skill description, docx, xlsx, Context window, built-in skills, custom skill
4.3 Creating custom skills for your workflow
The section uses architecture decision records to show how custom skills can make a valuable but often neglected team practice easier to follow.
- Decision records through custom skills: Explain why a team might use a custom skill to produce an Architecture Decision Record (ADR), and what information the ADR preserves.
Why it matters: A decision record helps future teammates understand the reasoning behind a choice without making documentation a large extra task. - Ingredients of a custom skill: Describe how this section says a custom skill can be put together and what assistance is available.
Why it matters: You can guide a repeatable task without having to write every part of the skill unaided.
Key terms: custom skill, Architecture Decision Record (ADR), decision points, markdown, scripts, sample inputs and outputs, skill-creator skill
4.4 Try it now — write a custom skill to generate ADRs
The section walks through creating an ADR-writing skill and explains how its instructions load and where the skill can be used.
- ADR skill creation request: Describe how to ask Claude in a Cowork project to create an adr-writer skill, including the decision supplied by the user and the ADR file the skill should produce.
Why it matters: A specific creation request gives the skill a clear input and a predictable output. - Editable skill instructions: Explain what the generated skill folder contains and how its behavior can be adjusted.
Why it matters: You can inspect and change the skill’s behavior by editing its instructions. - Staged skill loading: Trace when Claude loads a skill’s description, full instructions, and any reference files, and explain why descriptions must be concise and informative.
Why it matters: A good description lets Claude select the right skill while keeping startup context small. - Project versus saved availability: Distinguish using a skill left in its project folder from saving it through Claude Desktop’s skill-builder.
Why it matters: Where you keep the skill determines whether it is limited to a project or available across your work.
Key terms: Cowork project, adr-writer, Architecture Decision Record, docs/adr/{yymmdd}-{title}.md, skill folder, markdown, YAML, metadata, description, context
4.5 Try it now — use your skill to generate an ADR
The section shows how to use a custom skill to record an architecture decision and explains why the skill should stay focused, with room for user interaction.
- Recording a decision with a skill: Describe how to ask the custom skill to record a change of direction as an Architecture Decision Record (ADR), and what Claude produced in the example.
Why it matters: The example shows how a brief account of a decision can become a reusable project record. - Room for user interaction: Explain why an ADR skill need not be fully automated, using the suggested production improvements.
Why it matters: Leaving room for questions and challenge can improve the quality of a recorded decision. - Small and focused skill design: Justify keeping a skill limited to one clearly defined job rather than bundling tangential decision-related tasks.
Why it matters: A clear purpose helps Claude invoke the right skill at the right time.
Key terms: skill, Architecture Decision Record, ADR, consequences, alternatives, skills, decision points, interaction, uber-skill, description
4.6 Producing consistent outputs with skills
This section explains how custom skills make outputs consistent and efficient, preserve architectural context, and support shared team conventions.
- Consistent outputs from skills: Explain how a custom skill makes repeated outputs more consistent and reduces effort compared with nonspecific requests in separate chats.
Why it matters: A reusable skill helps you get a familiar result without specifying the process from scratch each time. - Versioned architectural decision context: Explain how consistently structured ADRs in a Git-backed project help a new human or Claude joiner understand the architecture.
Why it matters: Consistent, versioned decision records help newcomers understand why an architecture took shape. - Portable skills and team conventions: Describe how installed and repository-stored skills are available to different users, and how a team can share an agreed ADR convention.
Why it matters: Sharing the skill alongside the project makes a team’s agreed format easier to reuse.
Key terms: custom skills, ADR, consistent results, Git repo, commit history, architecture, skills, project repo, team convention, ADR format
4.7 Scheduled tasks: Recurring and on-demand automation
This section introduces how scheduled tasks run in Claude Desktop, where their results can go, and how to create a schedule.
- Scheduled task operation: Explain how a scheduled task differs from opening a live artifact and what must be running for the schedule to trigger.
Why it matters: This distinction helps you decide when a task should run unattended and what it needs to run. - Task output and confirmation: Describe how a connected Slack channel can provide a destination for scheduled-task output or confirmation.
Why it matters: An unattended task is useful only if you can find its result or tell that it ran. - Schedule creation approaches: Describe the two points at which you can create a schedule and the guidance Cowork provides.
Why it matters: You can schedule a task from the outset or turn a task you have already tried into a schedule.
Key terms: scheduled tasks, live artifact, Claude Desktop, output, Slack channel, connect, schedule, Cowork, built-in skill
4.8 Try it now — schedule a daily repo digest
Walks through setting up a daily Git repo digest in Claude Desktop, then explains how to run, manage, and safely automate schedules.
- Daily repo digest schedule: Describe a schedule that checks every branch for commits from the previous day at 05:00 and sends a summary to a Slack channel, including when there was no activity.
Why it matters: The digest gives you a reliable reminder of where you left off, even across multiple branches. - Slash command skill invocation: Explain how typing a slash lets you find available skills and how `/schedule` explicitly invokes the built-in schedule skill.
Why it matters: Finding and invoking the schedule skill makes it easier to start the task deliberately. - Schedule files and test runs: Describe where a schedule is stored, how to edit or run it in Claude Desktop, and why an initial run helps with connector permissions.
Why it matters: A test run lets you inspect the output and handle permissions before relying on the schedule. - Unattended automation safety boundary: Justify keeping pre-approved schedules to safe reading and drafting rather than potentially destructive actions that need your verification.
Why it matters: Pre-approval saves time, but it also means you may not be there to catch an unsafe action. - Independent runs and external state: Explain why each schedule run needs an external file for information it must carry forward, rather than updating its own schedule skill.
Why it matters: Keeping state outside the skill prevents a recurring task from losing its place or blocking future runs.
Key terms: /schedule, daily digest, branches, commits, daily-digest, slash-command, schedule skill, SKILL.md, user folder, Scheduled
4.9 Plugins: Bundling skills, connectors, and agents
This section explains how plugins package reusable Claude customizations for easy sharing and installation across Claude Desktop and Claude Code.
- Plugin packaging and sharing: Explain why plugins are useful when sharing multiple custom skills, and describe how a plugin and marketplace repository are organized.
Why it matters: Plugins make a growing collection of customizations easier for others to obtain and use. - Cross-platform plugin format: State where the same plugin format works and what that means for installing skills.
Why it matters: A shared format lets people use packaged skills across Claude’s desktop and coding environments.
Key terms: plugin, skills, connectors, custom agents, metadata, marketplace, Claude Desktop, Claude Code, plugin format
4.10 Try it now — install my plugin and create a GitHub issue
This section walks through installing a GitHub workflow plugin, checking its safety, and using its issue-creation skill in Claude Desktop.
- Plugin installation sequence: Describe how to add a repository marketplace in Claude Desktop, install its GitHub workflow plugin, and view the skills it provides.
Why it matters: Adding a marketplace alone does not install the plugin you want to use. - Third-party plugin safety: Explain why a public repository marketplace warrants caution and how Claude can help inspect a skills repository before use.
Why it matters: A reassuring skill name is not enough to establish what a third-party plugin will do. - Issue skill execution paths: Trace what happens when the create-issue skill is used for the scratchpad repository, including its GitHub CLI check and Desktop fallback.
Why it matters: The same skill can still help complete a task when its environment cannot perform the action directly. - Separate plugin repository: Justify keeping plugins in a repository separate from project code.
Why it matters: Separating plugins from application code makes plugin updates and installed-version checks easier to manage.
Key terms: marketplace, plugin, GitHub workflow plugin, skills, third-party marketplaces, permissions model, skills repos, hidden instructions, executable payloads, /create-issue
4.11 Designing automation workflows
This section explains when to create project skills, how to keep them manageable, and what benefits and costs to expect from automating workflows with Claude.
- Choosing project skills: Explain when an individual skill is sufficient and why keeping it in a project repository is useful. Describe where project-focused skills typically run.
Why it matters: It helps you recognize repeatable work that is worth packaging without assuming every workflow needs a plugin. - Tool driven project workflows: Describe, using examples from the section, how a project skill can guide Claude through work that uses tools and responds to results.
Why it matters: These examples show how a skill can guide more than a single fixed command. - Compact skill instructions: Explain why skill instructions should stay short and how to handle supporting information or pure automation.
Why it matters: A compact skill keeps unnecessary material out of context without preventing larger workflows. - Automation benefits and costs: Explain the productivity tradeoff of handing work to skills and scheduled tasks, including why skills need not be as exhaustive as scripts.
Why it matters: It helps you weigh saved effort against ongoing maintenance and token use.
Key terms: skills, plugins, project repos, Claude Code, CI/CD pipelines, CLI tool, REST API, A/B comparisons, cluster health, context
4.12 Your turn: Put your project on a maintenance schedule
This section walks through building and testing a scheduled skill that monitors a project’s platform versions and notifies you of relevant updates without making upgrades for you.
- Platform version baseline: Describe how to identify the project’s platform-level technologies from its design docs and record their current stable versions in an agent-friendly document.
Why it matters: A clear, agent-friendly version list gives the skill something reliable to check against new releases. - Update notification skill: Explain how the skill uses the version list to find new releases, notify Slack, and record what it has already reported.
Why it matters: Recording what was already reported makes recurring update alerts useful rather than repetitive. - Schedule testing and permissions: Describe how to test the skill with an intentionally old version before scheduling weekday runs, and identify the approvals needed for notifications and the schedule.
Why it matters: A trial run checks that the automation reports the right release before it starts running unattended. - Notification-only upgrade control: Explain why the scheduled automation reports release and security information but leaves upgrade decisions to the project owner.
Why it matters: You get early warning and useful evidence without handing an automated check the authority to change your stack.
Key terms: platform-level technologies, current stable versions, docs/platform/versions.md, agent-friendly format, skill, stack-updates, latest version it notified on, .claude/skills, stable release, edge release
4.13 Summary
Concepts explained in this chapter
- agent skillA skill is a reusable set of instructions and supporting resources that guides Claude through a particular task or workflow.
- pluginA plugin is a software component that extends a host application's functionality through an established extension interface.
- architecture decision recordAn architecture decision record is a document that captures a significant software architecture decision, its rationale, consequences, and alternatives.
- scheduled runA scheduled run is one execution of a task initiated by its schedule.
- stable releaseA stable release is a software version considered ready for dependable general use rather than experimental use.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
