Agent skill

Tech Contract Negotiation

by borghei in borghei/Claude-Skills

Negotiation frameworks for technology services agreements, B2B contracts, and professional services deals.

MITAuto-check passedBusiness, Finance & HR

Install Tech Contract Negotiation

skills CLI
$ npx skills add borghei/Claude-Skills --skill tech-contract-negotiation -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install borghei/Claude-Skills tech-contract-negotiation --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/borghei/Claude-Skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/legal/tech-contract-negotiation .claude/skills/tech-contract-negotiation && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
tech-contract-negotiation
GitHub stars
874
Token cost
~2.9k tokens
SKILL.md length
1,102 words
Files
6 (incl. scripts, references)
Skills in repo
364
Repo updated
First seen
Licence
MIT

At a glance

Negotiation frameworks for technology services agreements, B2B contracts, and professional services deals.

  • Works in 2 steps: Negotiation Position Analyzer… → Deal Complexity Scorer…
  • Negotiating tech contracts
  • SKILL.md covers Overview, Table of Contents, Clarify First and Tools, plus 7 more sections
  • Runs Python scripts from its folder; calls python

What it does

Tech Contract Negotiation is an agent skill from borghei/Claude-Skills. Negotiation frameworks for technology services agreements, B2B contracts, and professional services deals. Use when reviewing or negotiating tech contracts.

Its SKILL.md is about 2.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 7 other files, including scripts and reference files (for example `references/objection_handling.md`, `references/regulatory_leverage.md` and `references/three_position_framework.md`).

It sits in Business, Finance & HR, covering Vendor and procurement management. The repository describes itself as: 385 AI skills, 77 expert agents, and 900 stdlib Python tools for every team: engineering, PM, marketing, C-level, compliance, business ops, research, and a LinkedIn toolkit… The licence is MIT.

When your agent uses it

  • Negotiating tech contracts
  • Tasks that involve Vendor and procurement management

Example prompts

  • “/tech-contract-negotiation”

Requirements

  • Python 3

Workflow steps

2 steps, taken from the step headings in SKILL.md.

  1. Negotiation Position Analyzer (scripts/negotiation_position_analyzer.py)
  2. Deal Complexity Scorer (scripts/deal_complexity_scorer.py)

What it can do on your machine

Read from SKILL.md and the folder at commit c9a1487. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 2 files in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • python

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Tech Contract Negotiation loads about 2.9k tokens when it runs, and up to ~14k if it reads all its reference files. Until then it costs about 46 tokens; SKILL.md has 1,102 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~46
When it runs · the whole SKILL.md, loaded when a task matches
~2.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~14k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from borghei/Claude-Skills at commit c9a1487, republished under its MIT licence (© borghei). 1,102 words, ~2,864 tokens.

Download SKILL.mdSave it as .claude/skills/tech-contract-negotiation/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.
name
tech-contract-negotiation
description
Negotiation frameworks for technology services agreements, B2B contracts, and professional services deals. Use when reviewing or negotiating tech contracts.
license
MIT + Commons Clause
metadata.version
1.0.0
metadata.author
The Glass Room
metadata.category
legal
metadata.domain
contract-negotiation
metadata.updated
2026-04-10
metadata.tags
contract-negotiation, technology-agreements, B2B, SLA, indemnification

⚠️ EXPERIMENTAL — This skill is provided for educational and informational purposes only. It does NOT constitute legal advice. All responsibility for usage rests with the user. Consult qualified legal professionals before acting on any output.

Tech Contract Negotiation Skill

Overview

Production-ready negotiation toolkit for technology services agreements, professional services contracts, and B2B transactions. Provides a Three-Position Framework (provider-favorable, balanced, client-favorable) for every major provision, Deal-Size Tactics across 5 tiers, Five-Tier Objection Handling, regulatory leverage arguments, and concession roadmaps. Designed for legal counsel, procurement leads, and sales/deal desk teams negotiating technology contracts from $100K to $10M+.

Table of Contents

Clarify First

Before the analysis, confirm these inputs. If any is unknown or vague, ASK — do not assume:

  • Which side you are on — provider vs client — the --perspective input that flips position classification and your target positions
  • Deal value + complexity parameters — drive the deal tier (1-5), expected timeline, and number of rounds
  • Your bright lines / non-negotiables — define what cannot be conceded vs what can be traded in the concession roadmap
  • Applicable regulations — GDPR, DORA, NIS2, SOX — determine which regulatory-leverage arguments are genuine vs would destroy credibility

Stop rule: ask only the 2-3 that most change the output. If the user says "just draft it," proceed and list your assumptions at the top of the analysis.

Tools

1. Negotiation Position Analyzer (scripts/negotiation_position_analyzer.py)

Analyzes contract text and classifies each provision as provider-favorable, balanced, or client-favorable based on keyword patterns and structural analysis. Generates a position map and recommended negotiation priorities.

bash
# Analyze a contract draft
python scripts/negotiation_position_analyzer.py contract_draft.txt

# JSON output for integration
python scripts/negotiation_position_analyzer.py contract_draft.txt --json

# Analyze from a specific party's perspective
python scripts/negotiation_position_analyzer.py contract_draft.txt --perspective client
2. Deal Complexity Scorer (scripts/deal_complexity_scorer.py)

Takes deal parameters and scores complexity across 7 dimensions. Recommends deal tier (1-5), expected timeline, number of rounds, and key focus areas.

bash
# Score deal complexity from parameters file
python scripts/deal_complexity_scorer.py deal_params.json

# JSON output
python scripts/deal_complexity_scorer.py deal_params.json --json

# Override deal value for quick what-if
python scripts/deal_complexity_scorer.py deal_params.json --deal-value 5000000

Reference Guides

ReferencePurpose
references/three_position_framework.mdProvider/balanced/client positions for 5 major provisions with deal-size tactics
references/objection_handling.mdFive-tier objection methodology, prediction matrix, communication templates
references/regulatory_leverage.mdGDPR, DORA, NIS2, SOX leverage arguments, concession roadmap, industry considerations

Workflows

Workflow 1: Pre-Negotiation Assessment
  1. Classify the deal -- Run deal_complexity_scorer.py with deal parameters to determine tier, timeline, and focus areas
  2. Analyze the draft -- Run negotiation_position_analyzer.py on the initial contract to map current positions
  3. Identify gaps -- Compare position map against your target positions from three_position_framework.md
  4. Prepare objection responses -- Review objection_handling.md for predicted objections based on client type
  5. Map regulatory leverage -- Identify applicable frameworks from regulatory_leverage.md
Workflow 2: Active Negotiation
  1. Open with position -- Use the Opening Position Statement template from objection_handling.md
  2. Handle pushback -- Apply Five-Tier Objection Handling: Acknowledge, Market Context, Business Rationale, Alternatives, Bright Lines
  3. Track concessions -- Follow the 4-tier concession roadmap (Easy Gives through Bright Lines)
  4. Re-analyze after redlines -- Run negotiation_position_analyzer.py on each revised draft
  5. Close -- Use Closing the Deal template; verify no Bright Lines were crossed
Workflow 3: Deal Review and Approval
  1. Final position analysis -- Run analyzer on execution-ready draft
  2. Complexity validation -- Confirm final terms match expected deal tier parameters
  3. Regulatory check -- Verify all mandatory regulatory provisions are present
  4. Document concessions -- Record what was traded and why for future negotiations
  5. Approval package -- Combine position map, complexity score, and concession log

Troubleshooting

ProblemCauseSolution
Analyzer flags everything as "provider-favorable"Input is a vendor's first draft (expected behavior)Use --perspective provider to flip the analysis; compare against balanced baseline
Complexity scorer returns Tier 5 for a small dealHigh regulatory or multi-jurisdictional flags triggeredReview the regulatory and jurisdiction inputs; lower if overestimated
Position map shows no IP provisions detectedContract uses non-standard terminology for IP clausesCheck for terms like "work product," "deliverables ownership," or "background IP" manually
Deal timeline estimate seems too shortScorer does not account for internal approval delaysAdd internal review buffer (typically 1-2 weeks per approval level) to the estimated timeline
Objection framework doesn't cover a specific pushbackCounterparty raised an atypical demandStart with Acknowledge tier; frame using closest Market Context example; escalate to Bright Lines if needed
Regulatory leverage arguments rejected as irrelevantFramework doesn't apply to counterparty's jurisdictionVerify which regulations actually bind each party; remove inapplicable leverage points
Show full SKILL.md (433 more words)Show less

Success Criteria

  • Position Accuracy: Analyzer correctly classifies 85%+ of provisions when validated against expert review
  • Deal Tier Alignment: Complexity scorer tier matches actual negotiation effort within one tier for 90% of deals
  • Negotiation Efficiency: Average number of negotiation rounds reduced by 30% compared to ad-hoc approach
  • Concession Tracking: 100% of material concessions documented with rationale and trade-off analysis
  • Bright Line Protection: Zero instances of crossing defined Bright Lines without executive escalation and approval
  • Regulatory Coverage: All applicable regulatory provisions identified and addressed in 95%+ of contracts
  • Time-to-Signature: Deals close within estimated timeline +/- 20% for 80% of negotiations

Scope & Limitations

This skill covers:

  • Technology services agreements, SaaS subscriptions, professional services contracts, and B2B licensing deals
  • Negotiation position analysis for liability, IP, payment, SLA, and warranty provisions
  • Deal complexity scoring with tier-based recommendations for timeline, rounds, and focus areas
  • Regulatory leverage for GDPR, DORA, NIS2, and SOX in technology contract contexts
  • Objection handling frameworks and communication templates for common negotiation scenarios

This skill does NOT cover:

  • Employment agreements, M&A transactions, real estate contracts, or consumer-facing terms of service
  • Jurisdiction-specific legal advice or attorney-client privileged analysis (this is a framework, not legal counsel)
  • Contract drafting from scratch (assumes an existing draft to analyze and negotiate)
  • Litigation strategy, dispute resolution beyond contract clauses, or enforcement proceedings
  • Price negotiation tactics for commodity purchases or non-technology procurement

Anti-Patterns

Anti-PatternWhy It FailsBetter Approach
Treating every provision as a Bright LineCounterparty disengages when everything is non-negotiableClassify provisions into 4 concession tiers; trade Easy Gives early to build goodwill
Skipping deal complexity assessmentUnder-preparing for complex deals or over-preparing for simple onesAlways run complexity scorer first to calibrate effort, timeline, and approval requirements
Using regulatory leverage when the regulation doesn't applyDestroys credibility and trust with informed counterpartiesVerify applicability before citing any regulation; use the genuine-vs-preference test from the framework
Accepting "this is our standard template" at face valueEvery template is negotiable; accepting defaults leaves value on the tableAnalyze the "standard" template with the position analyzer to identify moveable provisions
Negotiating provisions in isolationConceding on SLAs without linking to liability caps creates exposureUse the Three-Position Framework holistically; link related provisions (SLAs to credits to liability)

Tool Reference

scripts/negotiation_position_analyzer.py

Analyze contract text and classify provisions by negotiation position.

usage: negotiation_position_analyzer.py [-h] [--json] [--perspective {provider,client}]
                                         input_file

positional arguments:
  input_file            Path to contract text file (.txt or .md)

options:
  -h, --help            Show help message and exit
  --json                Output results as JSON
  --perspective {provider,client}
                        Analysis perspective (default: client)

Outputs: Provision-by-provision position classification (provider-favorable / balanced / client-favorable), overall position score, position distribution summary, and prioritized negotiation recommendations.

scripts/deal_complexity_scorer.py

Score deal complexity across 7 dimensions and recommend negotiation parameters.

usage: deal_complexity_scorer.py [-h] [--json] [--deal-value DEAL_VALUE]
                                  input_file

positional arguments:
  input_file            Path to JSON file with deal parameters

options:
  -h, --help            Show help message and exit
  --json                Output results as JSON
  --deal-value DEAL_VALUE
                        Override deal value in dollars

Outputs: 7-dimension complexity breakdown (value, regulatory, technical, multi-party, duration, strategic importance, IP sensitivity), composite score, deal tier (1-5), recommended timeline, expected negotiation rounds, and key focus areas.

© borghei, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 5 other files (scripts, references) in legal/tech-contract-negotiation of borghei/Claude-Skills.

  • SKILL.md
  • references/objection_handling.md
  • references/regulatory_leverage.md
  • references/three_position_framework.md
  • scripts/deal_complexity_scorer.py
  • scripts/negotiation_position_analyzer.py

Open the folder on GitHubat commit c9a1487

Compare with similar skills

Tech Contract Negotiation next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Tech Contract Negotiation compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Tech Contract Negotiation this skillborghei/Claude-Skills874—~2.9kAutomated safety check: PassMIT
Serenity Alphahaskaomni/serenity-skill632—~2.6kAutomated safety check: PassMIT
Scorecard Matrixpnp/sharepoint-skills131—~1.9kAutomated safety check: PassMIT
Buyer Job Intent Analysiselvisun/newsjack1.5k—~1.4kAutomated safety check: PassMIT
Energy Procurementaffaan-m/ECC274k4 repos~7.4kAutomated safety check: PassApache-2.0
Master Builderibuilder/massing121—~2.6kAutomated safety check: PassMIT

Similar skills

  • Serenity Alpha

    haskaomni/serenity-skill

    Translate market-moving news into investable alpha hypotheses by mapping observed demand changes to revenue lines, supply chains, small-cap financial elasticity, market misclassification, validation…

    632 GitHub stars~2.6k tokensUpdated 2 mo ago
    Business, Finance & HRAuto-check passed
  • Scorecard Matrix

    pnp/sharepoint-skills

    Generates a polished, self-contained HTML heatmap scorecard — a weighted comparison matrix where entities (rows) are scored across dimensions (columns), with computed totals, rank badges, and a…

    131 GitHub stars~1.9k tokensUpdated yesterday
    Business, Finance & HRAuto-check passed
  • Recover source-bound buyer jobs, struggling moments, desired progress, forces, workarounds, information acts, journey states, criteria, constraints, roles, locales, and authentic language.

    1.5k GitHub stars~1.4k tokensUpdated today
    Business, Finance & HRAuto-check passed
  • Energy Procurement

    affaan-m/ECC

    Procure electricity and natural gas for commercial and industrial facilities: tariff and rate-schedule optimization, demand-charge mitigation, supplier RFPs, fixed/index/block-and-index hedging…

    274k GitHub starsUsed in 4 repos~7.4k tokens
    Business, Finance & HRAuto-check passed
  • Master Builder

    ibuilder/massing

    Reason like a master builder — one mind holding an entire built-asset project from raw land through design, construction, handover, operations, and disposition, anywhere in the world.

    121 GitHub stars~2.6k tokensUpdated 5 days ago
    Business, Finance & HRAuto-check passed
  • Procurement Audit

    vixues/LeAgent

    Review procurement contracts and purchase packages against uploaded compliance rules (招标/采购制度).

    231 GitHub stars~321 tokensUpdated 1 mo ago
    Business, Finance & HRAuto-check passed

More from borghei/Claude-Skills

All 364 skills in this repo
  • Agents In The Team

    borghei/Claude-Skills

    Run delivery when AI coding and ops agents take tickets. An agent skill from borghei/Claude-Skills.

    874 GitHub stars~4.2k tokensUpdated today
    Auto-check passed
  • AI Content Disclosure

    borghei/Claude-Skills

    Check AI-generated marketing content and reviews for required disclosures under the EU AI Act, FTC rules and platform AI-label policies.

    874 GitHub stars~3.4k tokensUpdated today
    Auto-check passed
  • AI Prototyping

    borghei/Claude-Skills

    Idea to AI-generated prototype to customer validation to engineering handoff.

    874 GitHub stars~3.6k tokensUpdated today
    Auto-check passed
  • Analytics Engineer

    borghei/Claude-Skills

    Analytics engineering across data modeling, dbt, transformation, and semantic layers.

    874 GitHub stars~3.4k tokensUpdated today
    Auto-check passed
  • Ansoff Matrix

    borghei/Claude-Skills

    Ansoff Matrix — 4-quadrant framework for growth options: market penetration, market/product development, and diversification.

    874 GitHub stars~2.2k tokensUpdated today
    Auto-check passed
  • Brainstorm Okrs

    borghei/Claude-Skills

    OKR brainstorming and validation using the Radical Focus framework — outcome objectives, measurable key results, counter-metrics.

    874 GitHub stars~1.4k tokensUpdated today
    Auto-check passed

Questions about Tech Contract Negotiation

What does Tech Contract Negotiation do?

Negotiation frameworks for technology services agreements, B2B contracts, and professional services deals. Tech Contract Negotiation is an agent skill from borghei/Claude-Skills. Negotiation frameworks for technology services agreements, B2B contracts, and professional services deals.

When should I use Tech Contract Negotiation?

Tech Contract Negotiation fits situations like: negotiating tech contracts; tasks that involve Vendor and procurement management.

How do I install Tech Contract Negotiation in Claude Code?

Run `npx skills add borghei/Claude-Skills --skill tech-contract-negotiation -a claude-code`. Or copy the skill folder (legal/tech-contract-negotiation in borghei/Claude-Skills) into .claude/skills/tech-contract-negotiation in your project. Claude Code loads it when a task matches its description.

How do I install Tech Contract Negotiation in Codex?

Run `npx skills add borghei/Claude-Skills --skill tech-contract-negotiation -a codex`. Or copy the skill folder (legal/tech-contract-negotiation in borghei/Claude-Skills) into .agents/skills/tech-contract-negotiation in your project. Codex loads it when a task matches its description.

Can I use Tech Contract Negotiation in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add borghei/Claude-Skills --skill tech-contract-negotiation -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/tech-contract-negotiation, .gemini/skills/tech-contract-negotiation, .github/skills/tech-contract-negotiation and .opencode/skills/tech-contract-negotiation in your project.

What does Tech Contract Negotiation need to run?

Going by SKILL.md and its folder, Tech Contract Negotiation needs Python for the scripts in its folder and the command-line tools its instructions call (python). Our summary lists: Python 3.

Does Tech Contract Negotiation access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Tech Contract Negotiation safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Tech Contract Negotiation use?

Tech Contract Negotiation is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Tech Contract Negotiation use?

About 2.9k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 11k tokens, read only when the agent opens those files.

What are the alternatives to Tech Contract Negotiation?

Skills that share tags, products or a category with Tech Contract Negotiation: Serenity Alpha (haskaomni/serenity-skill, 632 stars), Scorecard Matrix (pnp/sharepoint-skills, 131 stars), Buyer Job Intent Analysis (elvisun/newsjack, 1.5k stars) and Energy Procurement (affaan-m/ECC, 274k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Tech Contract Negotiation?

borghei (a GitHub user) maintains it in borghei/Claude-Skills, which has 874 GitHub stars. The repository holds 364 skills in this directory. The repository was last updated on October 7, 2026.

Source: borghei/Claude-Skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.