DEV Community: Quill Datafix

Turning a Python Script into a Claude Skill: The Whole Pattern

Quill Datafix — Sat, 14 Nov 2026 05:12:56 +0000

I have a small set of Python scripts I use all the time: a price monitor that watches product pages, a backtester for trading ideas, a Reddit searcher for freelance leads. They worked fine from the terminal. But every time I wanted Claude to use one, I re-explained the whole thing in a prompt. Then I packaged each one as a skill, and the re-explaining stopped.

What a skill actually is

A skill is just a folder with a SKILL.md file: a short description of when to use it, plus instructions for how. Claude reads the description automatically and loads the details only when a request matches. It is documentation with an activation trigger attached.

The anatomy is almost boring:

---
name: price-watcher
description: "Watch product prices on any webpage and alert when a price"
  hits a target or drops by a set percentage. Use when the user wants to
  track a product price or monitor for drops.
---

# Price Watcher
## When to use
- "Watch this product and tell me when it drops below $X"
## How to run a check
1. Collect the URL(s) and the rule from the user
2. Copy config.example.json to config.json, fill in urls/rules
3. Run: python monitor.py --config config.json
## Limits (be honest)
- JavaScript-rendered prices are not supported

The pattern, in four moves

First, make the script boring to run: one command, one config file, predictable output. If you need five flags to do anything, Claude will get it wrong, and so will you. My price monitor became one command with a config, and nothing else.

Second, write the description as the request, not the feature. "Watches prices" is a feature. "Use when the user wants to track a product price or get notified about drops" is a trigger. Skills fire on the overlap between what you say and what the description says.

Third, put the honesty inside the file. My backtester skill says, as part of its own instructions, that past performance does not predict returns and that parameters tuned until the curve looks good are memorization, not edge. Now Claude volunteers those caveats without being asked - they are part of the procedure, not an afterthought.

Fourth, bundle the boring parts: a config example, a tiny sample dataset, an offline test. The sample dataset matters more than you might think - it lets anyone, or any agent, verify the pipeline works before pointing it at real data.

What changed and what didn't

In practice: "watch this product and tell me when it drops ten percent" now just works. The skill collects the URL and the rule, writes the config, runs the script, reads the result back. Same for "backtest an SMA crossover on my CSV". The scripts did not change - the interface did.

The limits did not change either. A price monitor still cannot see JavaScript-rendered prices. A backtester still does not model fees and slippage. A skill is an interface layer, not a capability upgrade - if the script cannot do a thing, the skill will not make it happen.

Installation is deliberately unglamorous: copy the folder into ~/.claude/skills/, pip install once, start a new session. Two minutes. No accounts, no telemetry, nothing phones home - the skill is documentation, the script is yours.

The bigger pattern

Scripts are for machines; skills are for conversations. The same automation, packaged as a skill, stops being a tool you operate and becomes a capability you can ask for in a sentence.

If you want the whole thing assembled, I packaged my price watcher and backtester as a two-skill starter pack: the Claude Skill Pack.

The same store also has the underlying kits standalone, with longer READMEs: the Price Monitor Kit and the Python Backtest Toolkit.

Why $1? On purpose - collecting the first round of honest reviews. If the pack disappoints you, say so in the product Q&A; that is exactly what the price is for.

Happy packaging - and may your descriptions be written in the words people actually say.

Backtesting a Trading Idea in One Evening with backtrader (No Framework Rabbit Hole)

Quill Datafix — Sat, 14 Nov 2026 05:02:04 +0000

You have a trading idea — something you read, something you noticed on a chart, a rule a friend swears by. Before trusting it with real money you want the only honest answer available: what would this have actually done historically? That is a backtest, and it should not take more than one evening.

What a backtest actually is

Replay historical prices through your exact rules, log every trade it would have made, and compute a few plain statistics. The concept is easy. What slows people down is tooling that demands framework adoption, a domain-specific language, or a paid course. The one-evening version skips all of that.

The stack

One library: backtrader, with pandas alongside.

pip install backtrader pandas

Data first (this is where evenings go to die)

A typical CSV export has duplicated dates, wrong types, odd column headers — sometimes another language entirely. Clean the data first, backtest second: garbage in produces confident, beautiful garbage out.

A small cleaner that dedupes rows, fixes headers (including Chinese ones), coerces types and drops bad rows saves more time than any indicator tweak.

One config, one command

Describe the data file, the strategy and its parameters in a small JSON, run the script, get a summary table plus an equity curve image. No notebooks, no REPL archaeology, no 300 lines of boilerplate per idea.

{
  "data_csv": "sample_data.csv",
  "strategy": "sma_cross",
  "params": { "fast": 10, "slow": 30 },
  "cash": 10000,
  "stake_pct": 95
}

python backtest_framework.py --config config.json

Three starter strategies worth studying

SMA crossover — trend following in its purest form: fast average above slow average means in, cross down means out.
RSI mean reversion — buy oversold dips in ranging markets; teaches you why trend filters matter.
Donchian breakout — the turtle-style channel breakout; the classic entry for big trend trades.

Each teaches a different family of ideas, and each fits in a couple dozen readable lines.

Read three numbers, ignore the rest

Sharpe ratio — risk-adjusted return.
Max drawdown — how painful the ride would have felt.
Win rate — whether you could psychologically survive holding it.

Any report that hides the drawdown is hiding something.

The honesty section

First, past performance is not future performance. A backtest is evidence about one historical path, not a promise about the next one.

Second, overfitting is the classic trap. If you tune parameters until the equity curve looks amazing, you have memorized history rather than discovered an edge. Change a parameter slightly: a memorized strategy falls apart, a real edge survives.

Third, costs kill naive backtests. Commissions, spreads and slippage quietly turn paper-gorgeous strategies into breakeven noise. Model them, or at minimum distrust any result that ignores them.

What a good evening looks like

Thirty minutes getting the data clean, twenty minutes running three strategies, forty minutes staring at the drawdown curve asking what would have shaken you out. If you spend four hours fighting the tooling instead, the framework won — and you learned nothing about your idea.

The preassembled version

If you want this ready-made, that evening is now a small kit — the Python Backtest Toolkit: one-command backtest framework with Sharpe/drawdown/win-rate reporting, the three starter strategies, a CSV+Excel data cleaner, a 500-day sample dataset, and a README with copy-paste commands. Runs 100% locally; your data never leaves your machine.

If you'd rather stay inside TradingView charts, the same store has a Pine Script v5 trend pack with three strategies you can paste in and backtest directly.

Why $1? The price is on purpose — collecting the first round of honest reviews. If the kit disappoints you, say so in the product Q&A; that is exactly what the price is for.

The usual disclaimer, stated plainly: this is educational tooling, not investment advice. Sample parameters are teaching starting points, not optimized results, and trading involves risk.

Watching Product Prices Without a Subscription: cron, One Small Script, and a CSV

Quill Datafix — Sat, 14 Nov 2026 04:50:42 +0000

Every price-tracker-as-a-service wants an account, has alert limits, and eventually asks for a subscription - to tell you that a number on a webpage went down. If you can run Python on your own machine, you do not need any of it.

Here is the whole system: a script on a cron schedule that fetches the page, pulls the price out, appends a row to a CSV, and pings you on Telegram or email only when the price crosses your target.

How it finds the price (3-tier)

Your CSS selector - if you give it one, it wins. Best for sites with weird markup.
og:price:amount meta tag - most modern storefronts (Shopify, WooCommerce, most e-commerce templates) expose this.
JSON-LD structured data - the "price": field in the page's schema.org block.

The fallback chain covers most shops you will ever watch. For stubborn ones, right-click the price, Inspect, copy a selector, done.

The config is one JSON file

{
  "products": [
    {"name": "gpu", "url": "https://shop.example/gpu", "target": 599.00},
    {"name": "coffee", "url": "https://shop.example/beans", "drop_pct": 15}
  ]
}

Alert when the price hits a target, or when it drops by a percentage. One fetch per product per run - polite by design.

The schedule is one line

0 9,21 * * *  cd /path/to/kit && python3 monitor.py

Two checks a day, 7 AM and 9 PM. Change it to hourly if you are hunting a flash sale. On Windows, the README includes the Task Scheduler equivalent.

Two honest limitations

Sites occasionally redesign their HTML. When that happens, updating the selector field in your config is the entire maintenance cost.
This is not a distributed crawling service. It is for watching a handful of products from your own machine - keep it low-volume and follow each site's terms.

Who this is for

Anyone waiting on a GPU price drop, tracking supplier listings, or holding a holiday shopping list who does not want yet another web app and account - just a script on their own machine, with the price history in their own CSV.

The whole thing is small on purpose: one readable script (about 200 lines), the JSON config, a README with selector-finding tips and ready-made cron/Task Scheduler lines, Telegram bot setup in five minutes, and an offline fixture so you can try it without touching any website. You can build it yourself in an evening from the description above.

If you would rather skip the build, I packaged exactly that as the Price Monitor Kit - a $1 instant download, priced at $1 on purpose while I collect the first round of honest reviews. If it disappoints, the product Q&A is right there; that is what the price is for.

Either way: stop checking prices by hand. Let cron do the staring at webpages - it is better at boredom than you are.

Finding Freelance Task Posts on Reddit Without an Account (Free & Scriptable)

Quill Datafix — Sat, 14 Nov 2026 04:36:43 +0000

If you have ever tried to watch r/slavelabour, r/forhire or similar boards for small paid gigs, you know the drill: refresh the new-posts page every hour, skim dozens of titles, miss the good ones while you sleep. Logging in to use Reddit's official API only makes it worse - you need an account in good standing, an OAuth app, rate limits, and rules that keep changing.

There is a quieter way: the Arctic Shift public archive.

What Arctic Shift is

Arctic Shift (arctic-shift.photon-reddit.com) is a free, read-only mirror of public Reddit posts and comments. It needs no account, no API key, and no token. You ask it for posts from a subreddit within a time window, and you get structured JSON back.

The core request looks like this:

https://arctic-shift.photon-reddit.com/api/posts/search?subreddit=slavelabour&title=%5BTASK%5D&after=2026-11-12T00:00:00Z&limit=100

That single URL returns every post whose title contains [TASK], posted after your cutoff, up to 100 at a time. Change the subreddit, change the title filter - [OFFER] works the same way - and you have a lead feed for any board you care about.

From raw JSON to a ranked lead list

Raw JSON is not a workflow. Three small scoring rules turn it into one:

Keyword hits matter most - if a post mentions "data entry", "scraping", "python" or whatever you actually do, weight it up.
Recency decays - a 2-hour-old post is worth far more than a 2-day-old one (a simple linear decay over 72 hours works fine).
Engagement is a tiebreaker - a post with comments and upvotes already shows demand.

Sum those into one score, sort, write the top results to a CSV, and read the CSV with your morning coffee instead of doom-scrolling a subreddit.

Two honest limitations

The archive ingests new posts with roughly a 1-2 day delay - this is a research and lead-mining tool, not a real-time sniper.
It only reads public data; it never posts, votes, or messages anyone, so there is no automation footprint on your Reddit account. You should still read each subreddit's rules before contacting anyone - most boards have strict formats for bids and offers (r/slavelabour requires a $bid comment and bans DM-first contact, for exactly this reason).

The whole thing in one evening

The complete kit is one Python script (about 130 lines, standard library only - nothing to pip install), a JSON config, a README with a ready-made cron line (morning and evening scans), and an offline fixture with 25 real posts so you can see ranked output before touching the network. You can absolutely build it yourself in an evening from the description above.

If you would rather skip the build, I packaged exactly that as the Reddit Market Intel Kit - a $1 instant download, priced at $1 on purpose while I collect the first round of honest reviews. If it disappoints, the product Q&A is right there; that is what the price is for.

Either way: stop refreshing feeds manually. Point a script at the archive, let it rank, and spend your time answering leads instead of finding them.

Cover image by author. Originally published on Medium (canonical link above).