I have a folder of NDAs that need processing. For each NDA in
my /Legal/Inbox/NDAs folder:

1. Run NDA triage (standard/counsel review/full review)
2. Create a summary log in Excel with columns:
   - Filename
   - Counterparty
   - Type (mutual/one-way)
   - Triage Result
   - Key Issues Flagged
   - Recommended Action
3. Move files to appropriate subfolders:
   - /Standard_Approval for green
   - /Counsel_Review for yellow
   - /Full_Review for red
4. Generate a brief email summary I can send to the team

Save the Excel file as "NDA_Triage_[today's date].xlsx"
Save the email draft as "NDA_Summary_[today's date].docx"

I have 5 vendor agreements in /Legal/Vendor_Comparison folder.
Compare them and generate a professional report:

1. For each agreement, extract:
   - Vendor name
   - Annual cost
   - Term length
   - Liability cap
   - Indemnification scope
   - Data rights
   - SLA commitments
   - Notable unusual terms

2. Create a comparison matrix in Excel with:
   - Side-by-side comparison
   - Color coding (green=favorable, yellow=neutral, red=unfavorable)
   - Our standard position for reference

3. Generate a Word document report with:
   - Executive summary (1 page)
   - Detailed comparison analysis
   - Recommendations ranked by importance
   - Appendix with clause excerpts

Save as:
- "Vendor_Comparison_Matrix.xlsx"
- "Vendor_Comparison_Report.docx"

I need to process contracts from the data room. They're in
/Legal/DD/Contracts organized by type.

For this batch of /Legal/DD/Contracts/Customer_Agreements:

1. For each contract, extract and log:
   - Contract type
   - Counterparty
   - Effective date
   - Term/expiration
   - Annual value (if stated)
   - Auto-renewal terms
   - Change of control provisions
   - Assignment restrictions
   - Termination rights
   - Key risk flags

2. Create master Excel tracker with all data

3. Flag contracts requiring follow-up:
   - Approaching expiration (next 12 months)
   - Change of control consent required
   - Assignment restricted
   - Non-standard terms

4. Generate summary memo for deal team

Output:
- "DD_Contract_Tracker.xlsx"
- "DD_Contract_Summary_Memo.docx"

I have discovery documents in /Legal/SmithCase/Discovery that
I need to process into a trial timeline.

1. Scan all documents and extract:
   - Document date
   - Document type
   - Key parties involved
   - Summary of content
   - Relevance to our case theory
   - Helpful/harmful assessment

2. Create chronological timeline in Excel with:
   - Date
   - Event description
   - Document reference
   - Key quote (if applicable)
   - Our assessment (helps/hurts/neutral)

3. Generate Word document:
   - Narrative chronology (suitable for mediation brief)
   - Key events highlighted
   - Supporting document citations

4. Create PowerPoint:
   - Visual timeline for trial
   - Key dates marked
   - Clean professional design

Output:
- "SmithCase_Timeline_Master.xlsx"
- "SmithCase_Chronology_Narrative.docx"
- "SmithCase_Timeline_Presentation.pptx"

Process all contracts in /Legal/ActiveContracts and create
comprehensive portfolio analytics:

1. For each contract file, extract:
   - Contract ID
   - Contract name
   - Counterparty
   - Contract type (vendor/customer/partner/other)
   - Execution date
   - Effective date
   - Expiration date
   - Renewal dates
   - Annual value
   - Liability cap
   - Indemnity provisions
   - IP assignment scope
   - Data protection clauses
   - Termination notice period
   - Auto-renewal terms
   - Change of control restrictions
   - Key risk flags
   - Status (active/expired/pending renewal)

2. Create Excel workbook with:

   Sheet 1: Dashboard
   - Total contracts count
   - Total annual value (formula sum)
   - Expiring in next 30/90/180 days (conditional formatting)
   - Contracts requiring action (count)
   - Risk distribution pie chart

   Sheet 2: Master Data Table
   - All extracted fields
   - Sortable and filterable
   - Expiration date conditional formatting (red if <90 days)
   - Risk level color coding

   Sheet 3: Renewal Calendar
   - Sorted by expiration date
   - Assigned responsible parties
   - Renewal notice deadlines
   - Template action items

   Sheet 4: Risk Analysis
   - Contracts with liability caps <$1M
   - Missing indemnity provisions
   - Unrestricted IP assignment
   - Change of control issues
   - Non-standard termination

3. Generate summary memo highlighting:
   - Top portfolio risks
   - Expiration calendar (next 12 months)
   - Recommended priority actions
   - Estimated renewal values

Save as:
- "Portfolio_Analytics_[date].xlsx"
- "Portfolio_Risk_Summary.docx"

For the Portfolio_Analytics workbook:
1. Add Sheet 5: Vendor Spend Analysis
   - By vendor: contract count, total spend, renewal dates
   - Consolidation opportunities
   - Renegotiation candidates

2. Add Sheet 6: Compliance Checklist
   - Insurance requirements met
   - SOW sign-offs current
   - Required approvals documented
   - Annual compliance actions due

3. Generate compliance report with:
   - Audit trail of completed actions
   - Upcoming compliance deadlines
   - Responsible party assignments

I have a vendor MSA at /Legal/VendorNegotiations/Vendor_MSA_Draft.docx

Generate a redlined version with track changes showing our position:

1. Review the vendor's current draft
2. Compare against /Legal/Templates/Standard_MSA_Template.docx
3. Apply track changes for:
   - Our standard liability cap language
   - Our standard IP indemnity
   - Our standard data protection terms
   - Removal of problematic vendor liability caps
   - Addition of our standard payment terms
   - Our standard confidentiality provisions

4. For each change, add Word comments explaining:
   - Why we're making the change
   - What our standard position is
   - Why this protects both parties

5. Add a cover memo as first page with:
   - Executive summary of changes
   - Key negotiation points
   - Our red-line positions vs. nice-to-haves
   - Suggested response strategy

Save as "Vendor_MSA_OurRedlines_[date].docx"
This file will show all changes in track changes view

Generate detailed Word comments for this contract review:

Open /Legal/Reviews/ClientAgreement_Draft.docx and add:

1. In Definitions section:
   - Highlight ambiguous terms
   - Add comments with suggested clarifications
   - Reference case law where relevant

2. In Liability section:
   - Comment on cap amounts vs. industry standard
   - Flag mutual vs. one-sided caps
   - Suggest negotiation strategy

3. In IP Rights section:
   - Comment on scope of assignment
   - Flag background IP carveouts
   - Suggest protective language

4. In Termination section:
   - Comment on notice periods
   - Flag change of control provisions
   - Note renewal vs. termination mechanics

5. Create summary comment (at top of document) with:
   - Overall assessment
   - Top 3 issues to negotiate
   - Estimated negotiation timeline

All comments should be professional, actionable, and collaborative.

Save as "ClientAgreement_ReviewComments_[date].docx"

Apply firm standard formatting to contracts:

For all .docx files in /Legal/Drafts:

1. Apply styles:
   - Heading 1 for article titles
   - Heading 2 for subsections
   - Normal for body text
   - Emphasis for defined terms

2. Format consistently:
   - 1-inch margins
   - Times New Roman 12pt body
   - 1.15 line spacing
   - No tabs (use tables for structured content)
   - Page breaks before new articles
   - Headers with firm name/matter name
   - Footers with date and page numbers

3. Generate style sheet with:
   - Required styles defined
   - Formatting guidelines
   - Examples of proper formatting
   - Common mistakes to avoid

4. Create before/after samples showing
   transformation from inconsistent to firm standard

Save formatted contracts with "_Formatted" suffix
Save style guide as "Firm_Contract_Style_Guide.docx"

Analyze and reorganize my legal document library:

Process all files in /Legal/Documents (including subfolders):

1. For each file, determine:
   - Document type (contract/memo/motion/agreement/etc.)
   - Key parties involved
   - Date
   - Matter/client name
   - Current filename

2. Suggest new organized structure:
   - /Clients/[ClientName]/[YearQuarter]/[DocumentType]/
   - Example: /Clients/ABC_Corp/2024_Q1/Agreements/

3. Create CSV with columns:
   - Current path
   - Current filename
   - Suggested new folder
   - Suggested new filename
   - Rationale
   - File type
   - Date

4. Generate implementation guide:
   - Which moves are safe
   - Which require manual review
   - Backlinks to maintain
   - Archive recommendations

5. Provide conflict resolution:
   - Duplicate files (by content)
   - Similar files with different names
   - Obsolete versions to archive

Save as:
- "Reorganization_Plan_[date].xlsx"
- "Implementation_Guide.docx"

Find and flag duplicate documents:

Scan /Legal/ContractPortfolio and identify:

1. Exact duplicates (identical file content):
   - List with file locations
   - File sizes
   - Dates
   - Recommendation: keep newest, archive others

2. Near-duplicates (same document, minor variations):
   - Show differences
   - Suggest which version is "master"
   - Flag which should be archived

3. Multiple versions of same agreement:
   - Create version control summary
   - Identify most recent version
   - Archive previous versions to /Archive/
   - Create version control document

4. Generate Excel with:
   - Filename
   - File path
   - File size
   - Date
   - Match type (exact/near/version)
   - Action recommended
   - Risk if deleted

5. Create archive checklist:
   - Safe to archive immediately
   - Review before archiving
   - Do not archive (active matters)

Save as:
- "Duplicate_Analysis_[date].xlsx"
- "Archive_Checklist.docx"
- Archive old versions to /Archive/[Year]/

Translate contracts while preserving formatting:

Translate all English contracts in /Legal/Contracts/English/:

1. For each .docx file:
   - Extract text with formatting markers
   - Translate to Spanish maintaining legal terminology
   - Preserve all paragraph formatting
   - Keep table structure intact
   - Maintain header/footer
   - Preserve tracked changes if present

2. Translation quality:
   - Use legal Spanish terminology
   - Maintain formality appropriate to contract type
   - Keep defined terms consistent (suggest bilingual glossary)
   - Flag ambiguous English phrases for human review

3. Create bilingual glossary:
   - English defined terms → Spanish equivalents
   - Legal terminology matching
   - Context-specific meanings
   - Usage examples from contracts

4. Generate Spanish versions with:
   - Same formatting as English
   - Matching page breaks
   - Side-by-side comparison document
   - Translation notes where needed

5. Create quality assurance document:
   - Sentences requiring human verification
   - Terminology decisions made
   - Context-specific notes for translators
   - Proofreading checklist

Save as:
- /Legal/Contracts/Spanish/[Filename]_ES.docx
- "Translation_Glossary.xlsx"
- "Translation_QA_Report.docx"

Create unified bilingual contracts:

1. Take English contract /Legal/Contracts/Original.docx
2. Generate Spanish translation
3. Create side-by-side bilingual version with:
   - English on left, Spanish on right
   - Aligned by paragraph
   - Professional formatting
   - Table format for readability

4. Create separate documents:
   - English version (clean, ready to execute)
   - Spanish version (clean, ready to execute)
   - Bilingual reference version (internal only)

5. Generate translator's notes:
   - Terminology decisions
   - Ambiguities flagged
   - Legal system differences noted
   - Future translation consistency notes

Save as:
- "Contract_EN.docx" (English)
- "Contract_ES.docx" (Spanish)
- "Contract_Bilingual_Reference.docx"
- "Translator_Notes.docx"

Ensure translation consistency across all legal documents:

1. Analyze all Spanish translations in /Legal/Contracts/Spanish/
2. Extract defined terms and terminology from each
3. Create master terminology database:
   - English term
   - Spanish translation
   - Document sources
   - Frequency of use
   - Alternative translations considered

4. Flag inconsistencies:
   - Same English term with different Spanish translations
   - Similar terms with same translation (may be wrong)
   - Potential translation errors

5. Generate revision guide:
   - Recommendations for standardizing terminology
   - Priority fixes (high impact changes)
   - Documents requiring retranslation
   - Going-forward standards

6. Create terminology style guide:
   - Approved English→Spanish pairings
   - Rationale for each choice
   - Legal context notes
   - Examples

Save as:
- "Terminology_Database.xlsx"
- "Consistency_Report.docx"
- "Legal_Translation_Style_Guide.docx"

Create a client deliverable package:

Prepare documents for /Legal/ClientDeliverables/ABC_Corp_Matter/:

1. Gather documents:
   - Opinion letter (if applicable)
   - Summary memo
   - Supporting documents
   - Forms for execution
   - Cover sheet

2. Organize by document type:
   - Executive summary (first)
   - Documents requiring execution
   - Reference documents
   - Appendices

3. Generate client-facing cover memo:
   - Overview of documents
   - Required actions from client
   - Timeline for next steps
   - Key dates/deadlines
   - Responsible contacts
   - How to return executed documents

4. Create execution checklist:
   - Which documents need signatures
   - Who needs to sign
   - Signature authority verification
   - Witness/notary requirements
   - Return instructions

5. Add document index:
   - Document name
   - Purpose
   - Action required
   - Execution requirements

6. Create tracking spreadsheet:
   - Document name
   - Date sent
   - Status
   - Date received
   - Signature status
   - Notes

Save as:
- "Client_Deliverable_Package_[date]/" folder
- "Cover_Memo.docx"
- "Execution_Checklist.docx"
- "Document_Tracking.xlsx"

Generate client status update:

Create monthly status report for ABC_Corp matter:

1. Gather all recent activity:
   - Recent actions taken
   - Pending items
   - Upcoming deadlines
   - Issues requiring client input
   - Cost summary

2. Generate client-facing memo with:
   - Executive summary (1 page)
   - Detailed activity summary (what we did)
   - Current status (where we stand)
   - Next steps (what's coming)
   - Pending client actions
   - Timeline for next phase
   - Budget status
   - Contact for questions

3. Create action items section:
   - Items pending client response
   - Deadline for each
   - Impact if deadline missed
   - Instructions for client action

4. Add timeline visual:
   - What happened this period
   - Upcoming key dates
   - Milestones
   - Deadlines

5. Generate parallel internal memo:
   - Internal status for file
   - Risk flags not shared with client
   - Strategic notes
   - Next actions for team

Save as:
- "Status_Update_[Month]_[Client].docx"
- "Internal_Matter_Status.docx"

Create client-friendly summaries of technical documents:

Review /Legal/Matters/ABC_Corp/Research_Memos/:

1. For each detailed research memo:
   - Identify key conclusions
   - Extract legal standards
   - Note practical implications
   - Identify risks and opportunities
   - Simplify technical language

2. Generate two-version documents:

   Internal Version:
   - Detailed analysis
   - All legal citations
   - Nuanced analysis
   - Strategic considerations

   Client Version:
   - Executive summary (1-2 pages)
   - Plain-English explanation
   - Practical implications
   - Recommended actions
   - Simple visuals/charts
   - Minimal citations
   - No internal strategy

3. Create FAQ document:
   - Common client questions
   - Plain-language answers
   - Links to relevant sections
   - Contact for follow-ups

4. Add decision framework:
   - Options available
   - Pros/cons of each
   - Cost implications
   - Timeline
   - Recommended approach with rationale

Save as:
- "[Topic]_Internal_Analysis.docx"
- "[Topic]_Client_Summary.docx"
- "[Topic]_FAQ.docx"

Set up approval workflow tracking:

Create approval system for /Legal/ToBeApproved/:

1. Scan folder for documents needing approval
2. For each document, extract:
   - Document name
   - Type of approval needed
   - Required approver
   - Date submitted
   - Client impact
   - Urgency level
   - Required turnaround

3. Generate approval tracker Excel with:
   - Document name
   - Submitted date
   - Approver assigned
   - Status (pending/approved/rejected/revise)
   - Days pending (formula)
   - SLA deadline
   - Status indicators (color coding)

4. Create escalation rules:
   - Flag if >3 days pending
   - Escalate if >7 days pending
   - Alert if SLA about to breach

5. Generate daily/weekly reports:
   - What's pending approval
   - Days pending for each
   - At-risk items (approaching deadline)
   - Action items for approvers

6. Create automated reminder emails:
   - For pending approvals >3 days
   - For approaching deadlines
   - For stakeholders waiting on approval

Save as:
- "Approval_Tracker.xlsx"
- "Approval_Status_Report.docx"
- Automated reports to /Reports/Weekly/

Review the contract at /Legal/CurrentDeal/Draft_MSA.docx

Apply our standard playbook and generate a redlined version
with track changes showing:
- Deletions struck through
- Additions in red
- Comments explaining each significant change

Save as "Draft_MSA_OurRedlines.docx"

Analyze all contracts in /Legal/ContractPortfolio and create
an Excel workbook with:

Sheet 1: Summary Dashboard
- Total contract value
- Contracts by type (pie chart)
- Expiration calendar (next 12 months)
- Risk distribution

Sheet 2: Detailed Log
- All extracted contract data
- Conditional formatting for expiration dates
- Risk flags highlighted

Sheet 3: Renewal Calendar
- Contracts requiring action by month
- Responsible party assignment column

Save as "Contract_Portfolio_Analysis.xlsx"

Generate a board presentation covering Q1 legal matters:

Slide 1: Title - "Legal Department Q1 Update"
Slide 2: Key Metrics (contracts closed, disputes resolved, spend)
Slide 3: Major Matters Summary (table format)
Slide 4: Litigation Status (timeline visual)
Slide 5: Regulatory Developments (bullet points)
Slide 6: Looking Ahead Q2 (priorities)
Slide 7: Questions

Use professional business style. Include speaker notes
with key talking points.

Save as "Legal_Q1_Board_Update.pptx"

Set up a contract monitoring workflow:

1. Every Monday, scan /Legal/ActiveContracts for:
   - Contracts expiring in next 90 days
   - Auto-renewals with notice deadlines approaching
   - Contracts requiring annual compliance actions

2. Generate weekly report:
   - List of approaching deadlines
   - Required actions
   - Responsible parties

3. Create draft reminder emails for each deadline

Save to /Legal/WeeklyReports/[date]_ContractAlerts/

Search for recent regulatory developments in [practice area]
and generate a client alert:

1. Research recent [FDA/SEC/FTC/etc.] announcements
2. Summarize key developments
3. Analyze impact on our clients
4. Draft client alert memo
5. Create short version for LinkedIn post

Save:
- "Client_Alert_[Topic].docx" (full memo)
- "LinkedIn_Post_[Topic].txt" (short version)

Process the new vendor agreement in my inbox:

1. /triage-nda first to categorize urgency

2. If RED or YELLOW, then:
   /review-contract for full analysis

3. Based on review, generate:
   - Internal memo summarizing issues
   - Redlined contract with suggested changes
   - Email to business team with summary

4. Save all outputs to /Legal/[VendorName]_Review/

5. Log the review in our tracking spreadsheet

For each [document type] in [folder]:
[list of actions]
Save results to [output location]

Analyze [documents/data] and create:
1. [Excel tracker with columns: X, Y, Z]
2. [Word memo with sections: A, B, C]
3. [PowerPoint with slides: 1, 2, 3]
Save all to [location]

Extract from [documents in folder]:
[list of data points to extract]
Create Excel with columns: [X, Y, Z]
Add [formulas/formatting/charts]
Save to [location]

Review [document] and generate:
1. Tracked changes version
2. Detailed comments explaining each change
3. Summary memo of key issues
Save as [output filename]

Translate [documents in folder]:
[source language] → [target language]
Preserve all formatting and structure
Create glossary of terminology
Generate QA report
Save originals and translations to [location]

Create client deliverable package:
1. Organize documents by type
2. Generate cover memo
3. Create execution checklist
4. Set up tracking spreadsheet
Save to [folder]