If your team runs the same type of review, assessment, or approval process over and over, you’ve probably felt the drag of re-explaining context every single time. Skills fix that. Define the workflow once, and GC AI runs it on demand, the same way, every time.
Here’s what a Skill is, when to build one, and how to make it good enough to hand off to your whole team.
What Is a Skill?
A Skill is a set of reusable instructions you give to GC AI so it produces consistent, high-quality results on a task you do repeatedly. Instead of re-typing the same context and preferences into every chat, you write it once, save it to your library, and run it whenever the workflow comes up again. Skills can be reused across any chat, and you can stack more than one in a single conversation when their workflows overlap.
The best candidates are things like compliance or regulatory reviews, marketing campaign assessments, leadership approval packages, or a final quality check before a document goes out for signature. The payoff is less setup time, more consistent output, and a way to standardize how a task gets done across a whole department, not just for one person.
That last point matters. Skills work fine for individual use, but they’re most valuable when built for a team. The person closest to a workflow, who knows the edge cases and the judgment calls, is usually the best person to build the Skill. Once it’s tested, it can be shared across the department or the whole organization, with no retraining required.
No code required. If you’ve researched building “skills” or agents on other AI platforms, you may be picturing code files, YAML metadata, and zipped packages. GC AI Skills don’t work that way. You build them by having a conversation: describe what you want, GC AI asks a few clarifying questions, drafts the Skill, and saves it to your library. The result is written in plain language, so it’s readable and editable by anyone you grant access to.
When to Create a Skill
Not every task deserves a Skill. The strong candidates share three traits:
You or your team do the task repeatedly
It has a defined process or output that’s desirable every time
Quality or efficiency depends on doing the same steps in the same order
If a task is a one-off question or an open-ended brainstorm, skip the Skill and just use a regular chat.
What Goes Into a Skill
Every Skill is instruction text saved under a title, with a short description. When you add it to a chat, GC AI reads those instructions and follows them. That’s the whole mechanism, no configuration beyond the words you write.
Most Skills include some combination of the following:
Element | Purpose |
|---|---|
Objective | A short description of the Skill’s goal |
Input | What kind of input users will typically provide, such as a contract, a campaign description, or a piece of legislation |
Intake Questions | Questions GC AI should ask before starting, to gather context it can’t find in the documents or input |
Workflow Steps | The detailed sequence GC AI should follow to complete the task, in order |
Output Format | The exact structure of the response, such as a table, memo, checklist, or redline |
Always / Never Rules | Non-negotiable guardrails, phrased as absolutes |
Reference Documents | Files attached to the Skill that supply supplementary instructions, templates, or forms to complete |
A Complete Example Skill: Marketing Campaign Legal Review
Here is the shape of a complete Skill, using a workflow most in-house teams run weekly. Copy the structure and swap in your own standards.
Objective: Review proposed marketing campaign materials for legal risk and return a go, no-go, or revise recommendation with specific edits.
Input: The campaign brief and all consumer-facing copy, images, and claims.
Intake Questions: Which markets will this campaign run in? Does the campaign reference a competitor, partner, or third-party brand? Does it include a promotion, sweepstakes, or discount with conditions?
Workflow Steps:
Extract each factual claim in the copy and classify it as verifiable, puffery, or unsupported.
Check claims and disclosures against the advertising standards in the attached reference documents.
Review third-party references for trademark and right-of-publicity risk.
If a promotion is included, confirm the offer terms match the disclosure copy.
Produce the output in the format below.
Output Format: A table with three columns: Item, Risk Level (High, Medium, Low), and Recommended Edit. Below the table, a two-sentence overall recommendation.
Always/Never Rules: Always quote the exact copy language you are flagging. Always cite the reference document section that supports each flag. Never rewrite brand voice; propose the minimum edit that removes the risk. When a claim needs substantiation the documents do not contain, flag it as a business question for the campaign owner.
Reference Documents: Your advertising review checklist, brand guidelines, and prior campaign approvals.
Notice what the Skill encodes: the always/never rules carry the lawyer’s judgment, and the intake questions pull only what GC AI cannot read from the documents themselves. Extract first, ask second.
Core Design Principles
A few habits separate a Skill that works from one that falls apart the first time it hits an edge case:
Explain intent, not just rules. A rule with no reasoning gets followed mechanically and breaks the moment it hits a situation you didn’t anticipate. Give GC AI the reason behind the rule, and it can extend your judgment to new facts instead of guessing.
Be concise and clear. AI is literal. Make each instruction as clear as possible, and if you can cut a line without losing value, cut it.
Specify output format only when it matters. Over-constraining the format makes a Skill rigid for no reason.
Use structure. Headers, bullets, and numbered lists help GC AI follow a multi-phase workflow where sequence matters.
Give GC AI an example of a great result, if you have one. Attach model output during Skill creation so it can learn from it, but label it clearly as an example, not the required workflow, so it doesn’t get copied verbatim in future runs.
Prompt vs. Skill vs. Playbook vs. Agent
Both create consistency, but they solve different problems.
Skills are best for repeatable workflows that aren’t necessarily contract-based, though they can be. Think product launches, campaign reviews, or regulatory scans. If the workflow, intake, process, and output represent something your team does consistently, a Skill is the right choice.
Playbooks are best for structured, clause-by-clause contract reviews based on set negotiation rules, like standard positions, fallbacks, and escalation logic for NDAs, SaaS MSAs, or DPAs. If you review certain contract types in high volume and have clear rules for how your company handles them, a playbook fits better.
The two can also work together. A playbook run can be one phase inside a larger, multi-phased workflow captured in a Skill.
Four terms cover the reuse spectrum in GC AI, and most teams meet all four in their first month.
Term | What It Is | When to Reach for It |
|---|---|---|
Prompt | A single instruction for one task in one chat | One-off questions and first drafts |
Skill | Reusable instructions that run a repeatable workflow the same way each time | Multi-step work you repeat weekly or monthly |
Playbook | Clause-by-clause contract review standards with negotiation rules | NDA, MSA, and DPA review against your positions |
Agent | The execution layer that plans steps and carries a task to a finished deliverable | Any of the above, run with less steering |
The pattern to remember: prompts graduate into Skills, and Skills on a schedule become supervised agents.
Creating Your Skill
There are two starting points.
Start from scratch with the Skill Creator. Before you open it, think through the task itself: what the steps are, in order, what input users will typically provide, and what good output looks like. The Skill Creator will help you structure it from there.
Start from a chat you’ve already completed. If you’ve already run a workflow and liked the result, let that real conversation speak for itself instead of describing the process in the abstract. Add the Skill Creator to that chat and tell GC AI: “Look at what we did in this chat and create a Skill based on it.” You can layer in additional context at this stage too: things that were obvious to you but never stated, always/never rules you followed instinctively, or edge cases you’d want handled differently next time. GC AI will extract the steps, the intake questions, the output format, and the judgment calls you made, and draft a Skill from that.
Either way, review the draft, revise it, save it, and test it on a different set of facts before you trust it (more on that below).
Tips for Effective Skills
Design your intake questions carefully. Start by identifying what input users will typically provide, then figure out what additional context GC AI needs that isn’t in that input. Good intake gathers only what GC AI can’t find on its own. A useful instruction to build in: “Extract first, ask second. If information can be extracted from the attached documents or instructions, extract it; do not ask. Only ask for information that cannot be found in the documents or the initial input. If the user does not know, proceed and use a placeholder.”
If other people on your team will use the Skill, design intake questions that pull user-specific context, like project name, recipient, or deal-specific sensitivities, so anyone can run it and get a tailored result without touching the instructions themselves.
Be specific about workflow steps and output format. If the output requires a table, name the columns. If it requires a memo, name the sections. If steps have to run in a particular order, number them. If the workflow branches based on a user’s selection, map each path explicitly.
Use conditional logic where the workflow calls for it. This lets a single Skill change its output based on the user’s answers, instead of you maintaining several near-identical Skills side by side. For example: “Before generating the response, ask me the following questions. Begin the analysis only once the questions are answered. Then: if I select [X], produce the guide using the [X] approach; if I select [Y], produce the guide using the [Y] approach.”
Organize longer workflows into phases. If a Skill runs more than three or four steps, break it into named phases with explicit gates, and reinforce the gate at the end of each phase, not just once at the top. This keeps a long task from collapsing into a shallow one.
Chain follow-on deliverables. If a workflow naturally leads to a follow-up choice, have the Skill close its initial output by offering those next steps and asking the user to pick. Once they do, it delivers the next phase based on that choice.
Write your always/never rules with intent. These are your non-negotiables, so spell them out explicitly and phrase them as absolutes. GC AI can’t infer a rule you never stated. The most effective ones include the reasoning behind them. A few examples pulled from Skills already in production:
“Always quote the exact contract language and the section heading; never invent section numbers, and if there are none, identify the provision by its opening words.”
“Populate the attached form itself; never create a new memo or add sections that the form does not contain.”
“When in doubt, do not recommend a redline; treat it as a business item to escalate.”
“Always end with a recommendation, not a menu of options.”
“Do not proceed to Phase B until Phase A is complete.”
Control length and verbosity. AI models sometimes over-produce because they’re trying to be helpful. If length matters, set explicit page or word targets.
For prompts worth promoting into Skills, start from the 15 templates in AI prompts for lawyers.
Testing and Iterating
The Skills that give reliably good output are the ones tested on real workflows and refined over multiple runs. Before you dig into iteration, decide what a successful run actually looks like:
Does the output match your template?
Do the workflow steps run in sequence?
Is GC AI gathering what it needs before starting?
Is the recommendation specific enough to act on?
Is the output concise enough to use without trimming, but complete enough to act on?
From there, every round of testing follows the same loop:
Run and evaluate. Run the Skill on real work and evaluate the output.
Identify gaps. Was a step skipped? Was an answer vague? Was the output too long? Was the wrong perspective applied?
Revise and save. Tell GC AI exactly what went wrong and ask it to revise the Skill to fix that issue on future runs.
Test again. Repeat until output quality holds up consistently across different inputs.
When you iterate, you don’t start over. Open the Skill from its badge in the sidebar, edit it directly, or tell GC AI what to change. Ask to see the changes in strikethrough and bold so you can verify exactly what was modified.
A few common patterns worth knowing before you hit them yourself:
Symptom | Likely Cause | Fix |
|---|---|---|
Output template wasn’t followed correctly | Format instructions are buried or vague | Move format instructions to the top; specify column names and sort order explicitly; instruct GC AI to use the template only, without adding fields or sections |
Clarifying questions are asked about data already provided in a document | Intake doesn’t say to extract from documents first | Add: “Extract from uploaded documents first. Only ask for what cannot be found.” |
Steps collapse or run out of order | Phase gates are missing or weak | Add explicit gates: “Complete Phase A fully before proceeding to Phase B” |
Output is too long | No length discipline instructions | Add a word or page cap; specify answer length per prompt type |
Using, Automating, and Sharing Skills
Browse the library first. The GC AI Skill Library includes Skills built and refined by in-house lawyers reflecting common workflows. Browsing them, or copying one to adapt, is one of the fastest ways to see what a well-built Skill looks like before you write your own.
Your team’s Skills live in the Skill Library, alongside the pre-built ones GC AI ships for NDAs, DPAs, regulatory summaries, and board consents.
Running a Skill is simple. Open it from the sidebar and click “Use.” GC AI attaches the instructions to the chat. Click “Run,” and it will review the instructions and follow up with any questions it needs answered to complete the workflow. You can add multiple Skills to one conversation when their workflows align, and GC AI will run them together.
Automate what can run on a schedule. Once a Skill is working reliably, and the task itself can be automated, use “Automate this Skill” to run it on a recurring basis, useful for regular compliance reviews, weekly digests, or periodic checks of a vendor’s terms of service to see if anything changed. GC AI delivers results to your chat history, or emails them to you directly.
Share what works. From your Skills section, you can give specific teammates edit access so they can help refine a Skill, or open read-only access to your whole organization. A single, well-tested Skill can become the department standard. If your team is building several Skills, it’s worth designating one or two people to own the library, test new Skills before rolling them out broadly, and fold team feedback into each iteration.
KT Farley, Chief Privacy Officer and Associate GC at Helix, described what shared reusable workflows changed for her team:
“The ability to create and store reusable prompts and share them across the team has completely changed the work required to review standard work. Junior teammates now run the checklist prompt first and bring me the output as the predicate for my review.”
That is the payoff of read-only sharing: one standard, run identically, with review time spent on judgment.
What AI Skills Should In-House Lawyers Build First?
Start with the task your team repeats most: NDA review, vendor terms checks, or marketing approvals. Build the Skill while a lawyer still runs the workflow manually, test it against matters you have already completed, then share it read-only so the team runs one standard. High volume plus repeatable structure is the profile where a Skill pays back fastest.
Have questions about building Skills in GC AI? Reach out to your GC AI account representative.
Frequently Asked Questions
What is a Skill in GC AI?
A Skill is a set of reusable instructions saved to your library that GC AI follows to complete a repeatable workflow. Instead of re-explaining context every time, you define the objective, intake questions, workflow steps, and output format once, then reuse it across any chat.
Do you need to code to build a Skill in GC AI?
No. GC AI Skills are built entirely through conversation, not code files or YAML. You describe the workflow, GC AI asks clarifying questions, drafts the Skill, and saves it in plain language that anyone with access can read or edit.
When should I create a Skill instead of using a regular chat?
Create a Skill when a task is repeatable and consistency matters: you or your team do it regularly, it has a defined process or output, and quality depends on following the same steps in the same order. One-off questions or open-ended brainstorming are better handled in a regular chat.
What is the difference between a Skill and a Playbook in GC AI?
Skills are best for repeatable workflows that aren’t necessarily contract-based, like product launches or regulatory scans. Playbooks are best for structured, clause-by-clause contract reviews with set negotiation rules, such as NDAs, SaaS MSAs, or DPAs. The two can be combined, with a playbook run as one phase inside a larger Skill.
Can a GC AI Skill be shared with a team?
Yes. Skills can be shared with edit access for specific teammates who help refine them, or read-only access across an entire organization, turning a single tested Skill into a department-wide standard.
Can GC AI Skills run on a schedule automatically?
Yes, using Automate this Skill. This runs a working Skill on a recurring schedule, useful for regular compliance reviews, weekly digests, or periodic checks of a vendor’s terms of service, with results delivered to chat history or by email.
