Skill: Excel / XLSX

Owner: ivangdavila

Summary: Create, inspect, and edit Microsoft Excel workbooks and XLSX files with reliable formulas, dates, types, formatting, recalculation, and template preservation...

Tags: latest:1.0.2

Version history:

v1.0.2 | 2026-03-11T15:32:46.499Z | user

Tightened formula anchoring, recalculation, and model traceability after a stricter external spreadsheet audit.

v1.0.1 | 2026-02-23T11:48:02.734Z | user

Added Core Rules and modern skill structure

v1.0.0 | 2026-02-10T01:20:33.325Z | user

Initial release

Archive index:

Archive v1.0.2: 2 files, 3497 bytes

Files: SKILL.md (6960b), _meta.json (129b)

File v1.0.2:SKILL.md

---

name: Excel / XLSX slug: excel-xlsx version: 1.0.2 homepage: https://clawic.com/skills/excel-xlsx description: "Create, inspect, and edit Microsoft Excel workbooks and XLSX files with reliable formulas, dates, types, formatting, recalculation, and template preservation. Use when (1) the task is about Excel, .xlsx, .xlsm, .xls, .csv, or .tsv; (2) formulas, formatting, workbook structure, or compatibility matter; (3) the file must stay reliable after edits." changelog: Tightened formula anchoring, recalculation, and model traceability after a stricter external spreadsheet audit. metadata: {"clawdbot":{"emoji":"📗","requires":{"bins":[]},"os":["linux","darwin","win32"]}}

When to Use

Use when the main artifact is a Microsoft Excel workbook or spreadsheet file, especially when formulas, dates, formatting, merged cells, workbook structure, or cross-platform behavior matter.

Core Rules

1. Choose the workflow by job, not by habit

• Use pandas for analysis, reshaping, and CSV-like tasks.
• Use openpyxl when formulas, styles, sheets, comments, merged cells, or workbook preservation matter.
• Treat CSV as plain data exchange, not as an Excel feature-complete format.
• Reading values, preserving a live workbook, and building a model from scratch are different spreadsheet jobs.

2. Dates are serial numbers with legacy quirks

• Excel stores dates as serial numbers, not real date objects.
• The 1900 date system includes the false leap-day bug, and some workbooks use the 1904 system.
• Time is fractional day data, so formatting and conversion both matter.
• Date correctness is not enough if the number format still displays the wrong thing to the user.

3. Keep calculations in Excel when the workbook should stay live

• Write formulas into cells instead of hardcoding derived results from Python.
• Use references to assumption cells instead of magic numbers inside formulas.
• Cached formula values can be stale, so do not trust them blindly after edits.
• Check copied formulas for wrong ranges, wrong sheets, and silent off-by-one drift before delivery.
• Absolute and relative references are part of the logic, so copied formulas can be wrong even when they still "work".
• Test new formulas on a few representative cells before filling them across a whole block.
• Verify denominators, named ranges, and precedent cells before shipping formulas that depend on them.
• A workbook should ship with zero formula errors, not with known #REF!, #DIV/0!, #VALUE!, #NAME?, or circular-reference fallout left for the user to fix.
• For model-style work, document non-obvious hardcodes, assumptions, or source inputs in comments or nearby notes.

4. Protect data types before Excel mangles them

• Long identifiers, phone numbers, ZIP codes, and leading-zero values should usually be stored as text.
• Excel silently truncates numeric precision past 15 digits.
• Mixed text-number columns need explicit handling on read and on write.
• Scientific notation, auto-parsed dates, and stripped leading zeros are common corruption, not cosmetic issues.

5. Preserve workbook structure before changing content

• Existing templates override generic styling advice.
• Only the top-left cell of a merged range stores the value.
• Hidden rows, hidden columns, named ranges, and external references can still affect formulas and outputs.
• Shared strings, defined names, and sheet-level conventions can matter even when the visible cells look simple.
• Match styles for newly filled cells instead of quietly introducing a new visual system.
• If the workbook is a template, preserve sheet order, widths, freezes, filters, print settings, validations, and visual conventions unless the task explicitly changes them.
• Conditional formatting, filters, print areas, and data validation often carry business meaning even when users only mention the numbers.
• If there is no existing style guide and the file is a model, keep editable inputs visually distinguishable from formulas, but never override an established template to force a generic house style.

6. Recalculate and review before delivery

• Formula strings alone are not enough if the recipient needs current values.
• openpyxl preserves formulas but does not calculate them.
• Verify no #REF!, #DIV/0!, #VALUE!, #NAME?, or circular-reference fallout remains.
• If layout matters, render or visually review the workbook before calling it finished.
• Be careful with read modes: opening a workbook for values only and then saving can flatten formulas into static values.
• If assumptions or hardcoded overrides must stay, make them obvious enough that the next editor can audit the workbook.

7. Scale the workflow to the file size

• Large workbooks can fail for boring reasons: memory spikes, padded empty rows, and slow full-sheet reads.
• Use streaming or chunked reads when the file is big enough that loading everything at once becomes fragile.
• Large-file workflows also need narrower reads, explicit dtypes, and sheet targeting to avoid accidental damage.

Common Traps

• Type inference on read can leave numbers as text or convert IDs into damaged numeric values.
• Column indexing varies across tools, so off-by-one mistakes are common in generated formulas.
• Newlines in cells need wrapping to display correctly.
• External references break easily when source files move.
• Password protection in old Excel workflows is not serious security.
• .xlsm can contain macros, and .xls remains a tighter legacy format.
• Large files may need streaming reads or more careful memory handling.
• Google Sheets and LibreOffice can reinterpret dates, formulas, or styling differently from Excel.
• Dynamic array or newer Excel functions like FILTER, XLOOKUP, SORT, or SEQUENCE may fail or degrade in older viewers.
• A workbook can look fine while still carrying stale cached values from a prior recalculation.
• Saving the wrong workbook view can replace formulas with cached values and quietly destroy a live model.
• Copying formulas without checking relative references can push one bad range across an entire block.
• Hidden sheets, named ranges, validations, and merged areas often keep business logic that is invisible in a quick skim.
• A workbook can appear numerically correct while still failing because filters, conditional formats, print settings, or data validation were stripped.
• A workbook can be numerically correct and still fail visually because wrapped text, clipped labels, or narrow columns were never reviewed.

Related Skills

Install with clawhub install <slug> if user confirms:

• csv — Plain-text tabular import and export workflows.
• data — General data handling patterns before spreadsheet output.
• data-analysis — Higher-level analysis that can feed workbook deliverables.

Feedback

• If useful: clawhub star excel-xlsx
• Stay updated: clawhub sync

File v1.0.2:_meta.json

{ "ownerId": "kn73vp5rarc3b14rc7wjcw8f8580t5d1", "slug": "excel-xlsx", "version": "1.0.2", "publishedAt": 1773243166499 }

Archive v1.0.1: 4 files, 4933 bytes

Files: memory-template.md (1881b), setup.md (2642b), SKILL.md (3828b), _meta.json (129b)

File v1.0.1:SKILL.md

---

name: Excel / XLSX slug: excel-xlsx version: 1.0.1 homepage: https://clawic.com/skills/excel-xlsx description: Read, write, and generate Excel files with correct types, dates, formulas, and cross-platform compatibility. changelog: Added Core Rules and modern skill structure metadata: {"clawdbot":{"emoji":"📗","requires":{"bins":[]},"os":["linux","darwin","win32"]}}

Setup

On first use, read setup.md for integration guidelines. Ask user preferences naturally during conversation.

When to Use

User needs to read, write, or generate Excel files (.xlsx, .xls, .xlsm). Agent handles type coercion, date serialization, formula evaluation, and cross-platform quirks.

Architecture

Memory lives in ~/excel-xlsx/. See memory-template.md for structure.

~/excel-xlsx/
└── memory.md     # Preferences, tools, pain points

Quick Reference

| Topic | File | |-------|------| | Setup | setup.md | | Memory template | memory-template.md |

Core Rules

1. Dates Are Serial Numbers

Excel stores dates as days since 1900-01-01 (Windows) or 1904-01-01 (Mac legacy). Check workbook date system before converting. Time is fractional: 0.5 = noon, 0.25 = 6 AM.

2. The 1900 Leap Year Bug

Excel incorrectly treats 1900 as a leap year. Serial 60 represents Feb 29, 1900 (invalid date). Account for this when calculating dates before March 1, 1900.

3. 15-Digit Precision Limit

Numbers beyond 15 digits silently truncate. Use TEXT format for: phone numbers, IDs, credit cards, any long numeric identifiers. Leading zeros also require TEXT.

4. Formulas vs Cached Values

Cells may contain both formula and cached result. Some readers return formula string, others return cached value. Force recalculation if cached values might be stale.

5. Merged Cells Are Traps

Only the top-left cell of a merged range holds the value. Reading other cells in the merge returns empty. Hidden rows/columns still contain data.

6. Cross-Platform Testing Required

Windows vs Mac Excel can differ in date system. LibreOffice/Google Sheets may not support all features. Always test roundtrip compatibility when generating files for unknown consumers.

7. Use Streaming for Large Files

Loading large files fully into RAM causes memory issues. Use streaming readers (row-by-row) for files with 100K+ rows. Empty rows at end may be padded by some writers.

Common Traps

• Type inference on read → Numbers stored as text stay text; explicit conversion needed
• Column index confusion → A=0 or A=1 varies by library; always verify convention
• Newlines in cells → \n works but cell needs "wrap text" format to display
• External references → [Book.xlsx]Sheet!A1 breaks when source file moves
• Password protection → Trivial to break; not real security; encrypt file externally if needed
• XLSM files → Contain macros (security risk); XLSB is binary (faster but less compatible)
• Shared strings → Large files reuse text indices; libraries handle this, but be aware

Format Limits

| Format | Rows | Columns | Notes | |--------|------|---------|-------| | XLSX | 1,048,576 | 16,384 (XFD) | Modern default | | XLS | 65,536 | 256 | Legacy, avoid | | CSV | Unlimited | Unlimited | No formatting |

Security & Privacy

Data that stays local:

• All file processing happens locally
• User preferences stored in ~/excel-xlsx/memory.md with consent
• No external services called

This skill does NOT:

• Send data to external endpoints
• Require network access

Related Skills

Install with clawhub install <slug> if user confirms:

• csv — CSV parsing and generation
• data — Data processing patterns
• data-analysis — Analysis workflows

Feedback

• If useful: clawhub star excel-xlsx
• Stay updated: clawhub sync

File v1.0.1:_meta.json

{ "ownerId": "kn73vp5rarc3b14rc7wjcw8f8580t5d1", "slug": "excel-xlsx", "version": "1.0.1", "publishedAt": 1771847282734 }

File v1.0.1:memory-template.md

Memory Template — Excel / XLSX

Create ~/excel-xlsx/memory.md with this structure:

# Excel / XLSX Memory

## Status
status: ongoing
last: YYYY-MM-DD
integration: pending | done | declined

## Environment
platform: windows | mac | linux | mixed
libraries: [openpyxl, pandas, xlsxwriter, SheetJS, etc.]

## Preferences
date_system: 1900 | 1904 | auto
date_format: DD/MM/YYYY | MM/DD/YYYY | YYYY-MM-DD | none
numeric_ids: always_text | when_needed | none
large_files: suggest_streaming | handle_normally

## Pain Points
<!-- Things they've mentioned struggling with -->
- [e.g., "dates always break when opening on Mac"]
- [e.g., "phone numbers lose leading zeros"]

## Common Tasks
<!-- What they typically do with Excel -->
- [e.g., "export reports for finance team"]
- [e.g., "import CSVs from legacy system"]

## Notes
<!-- Other observations -->

---
*Updated: YYYY-MM-DD*

Status Values

| Value | Meaning | Behavior | |-------|---------|----------| | ongoing | Still learning | Gather context as they work | | complete | Has enough context | Work normally | | paused | User said "not now" | Don't ask, work with what you have |

Preference Defaults

If no preference specified, use these sensible defaults:

• date_system: auto (detect from workbook)
• date_format: ISO (YYYY-MM-DD) when generating, preserve when reading
• numeric_ids: when_needed (warn for >15 digits or leading zeros)
• large_files: suggest_streaming (mention for 100K+ rows)

What to Track Over Time

As you help them:

• Note which warnings actually helped vs annoyed them
• Remember which libraries they use
• Track recurring issues (same mistake = add to pain points)
• Update preferences when they express them

Integration Note

After user confirms their preferences:

• Save when to activate this skill
• Save key preferences for future sessions

File v1.0.1:setup.md

Setup — Excel / XLSX

Read this on first use to understand user preferences. Ask questions naturally during conversation.

Your Attitude

You're helping someone who works with Excel files. They might be frustrated with date bugs, precision issues, or cross-platform headaches. Show that you understand these pains and will help them avoid them.

Use natural language: Talk about Excel pitfalls and best practices, not about "memory files" or "config". The user cares about getting their spreadsheets right.

Priority Order

1. First: Integration (most important)

Before anything else, figure out WHEN this skill should activate.

Help the user understand what this enables:

• "I can help whenever you're working with Excel files — reading, writing, or generating them. Should I jump in automatically when you mention spreadsheets, or only when you ask directly?"

Wait for their answer. Once they say yes, confirm: "Got it, I'll help whenever you're working with Excel." Then save their preference.

2. Then: Understand Their Situation

Ask open questions to understand how they work with Excel:

• What do they use Excel for? (reports, data import/export, analysis, templates?)
• What tools/libraries do they use? (openpyxl, pandas, SheetJS, xlsxwriter, manual?)
• What platforms? (Windows, Mac, Linux, or mixed?)
• Any recurring pain points? (dates, encoding, large files?)

Start broad, then narrow based on what matters to them.

3. Finally: Preferences (only if they want)

Some users have strong preferences about:

• Date system (1900 vs 1904)
• Date format (DD/MM/YYYY vs MM/DD/YYYY vs ISO)
• How to handle numeric IDs (always text, or only when needed)
• Large file handling (when to suggest streaming)

Adapt to them. Don't push for details they don't care about.

Feedback After Each Response

After the user shares something:

1. Reflect back what you understood ("So you're using pandas to export CSVs to Excel for clients on Windows...")
2. Connect it to how you'll help ("I'll make sure dates convert correctly and IDs don't lose precision")
3. Then continue

What You're Saving (with consent)

Only save after the user shares it:

• Integration preference (when to activate)
• Tools/libraries they use
• Primary platform (Windows/Mac/Linux)
• Date preferences (if mentioned)
• Known pain points to watch for

Always confirm what you understood: "Got it, I'll warn you about the 1900 date bug when working with older files."

When Setup is "Done"

Once you know:

1. When to activate
2. What tools/platform they use

...you're ready to help. Preferences build over time through normal use.

Archive v1.0.0: 2 files, 1780 bytes

Files: SKILL.md (2577b), _meta.json (129b)

File v1.0.0:SKILL.md

---

name: XLSX description: Read and generate Excel files with correct types, dates, and cross-platform compatibility. metadata: {"clawdbot":{"emoji":"📗","os":["linux","darwin","win32"]}}

Dates

• Excel dates are serial numbers—days since 1900-01-01 (Windows) or 1904-01-01 (Mac legacy)
• 1900 leap year bug: Excel incorrectly treats 1900 as leap year—serial 60 is Feb 29, 1900 (invalid)
• Date vs number ambiguous without cell format—always check number format code, not just value
• Times are fractional days: 0.5 = 12:00 noon; 0.25 = 06:00

Numbers

• 15-digit precision limit—larger numbers silently truncate; use text format for IDs, phone numbers
• Leading zeros stripped from numbers—format as text or use custom format 00000
• Scientific notation triggers automatically—1E10 becomes number; quote if literal text
• Currency/percentage stored as numbers—formatting is display-only, raw value differs

Text & Encoding

• Shared strings table stores unique text once—large files reuse indices; libraries handle this
• 32,767 character limit per cell
• Newlines in cells: \n works but cell needs wrap text format to display
• Unicode fully supported in XLSX—but legacy XLS has codepage issues

Structure

• Row limit: 1,048,576; column limit: 16,384 (XFD)—XLS limit is 65,536 × 256
• Merged cells: only top-left cell holds value—reading others returns empty
• Hidden rows/columns still contain data—don't assume hidden means excluded
• Sheet names max 31 chars; forbidden: \ / ? * [ ]

Formulas

• Cell may contain formula and cached result—some readers return formula, others cached value
• Formulas recalculate on open—cached values may be stale; force recalc or read formula
• Array formulas (CSE/dynamic) have different behavior across Excel versions
• External references [Book.xlsx]Sheet!A1 break when file moves

Cross-Platform

• Windows vs Mac Excel: date system (1900 vs 1904) can differ—check workbook setting
• LibreOffice/Google Sheets: some Excel features unsupported—test roundtrip
• XLSM contains macros (security risk); XLSB is binary (faster, less compatible)
• Password protection is trivial to break—not real security; encrypt file externally

Common Library Issues

• Empty rows at end: some writers pad to fixed size—trim when reading
• Type inference on read: numbers-as-text stay text; explicit conversion needed
• Memory: loading large files fully into RAM—use streaming reader for big files
• Column letters vs indices: A=0 or A=1 varies by library—verify convention

File v1.0.0:_meta.json

{ "ownerId": "kn73vp5rarc3b14rc7wjcw8f8580t5d1", "slug": "excel-xlsx", "version": "1.0.0", "publishedAt": 1770686433325 }