DEV Community: IntelliTools

How I Built a Python Workflow for HackerNews Job Auditor

IntelliTools — Mon, 11 May 2026 19:37:04 +0000

Shipping reliable automation tools is mostly about reducing repeated manual work.

In this post I walk through a practical pattern I use to build and ship a focused utility: HackerNews Job Auditor.
The goal is simple: solve one painful workflow with a script a developer can run locally in minutes.

What problem this script solves

Most teams lose time in repetitive steps that are easy to automate but expensive to keep doing manually.
For this project, I focused on the parts that usually burn time: setup friction, inconsistent output, and no clear handoff artifact.

The approach is:

Make one script handle the core workflow.
Keep output deterministic and readable.
Package it with a README and sample output so anyone can run it quickly.

Minimal runnable structure

from pathlib import Path

def run_workflow(input_path: str) -> dict:
    text = Path(input_path).read_text(encoding="utf-8")
    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
    return {
        "line_count": len(lines),
        "char_count": len(text),
        "has_errors": any("error" in ln.lower() for ln in lines),
    }

print(run_workflow("sample_input.txt"))

This keeps the first pass intentionally small. You can run it instantly and verify the output before adding complexity.

Add a useful report layer

import json
from datetime import datetime

def save_report(report: dict, output_file: str = "report.json") -> None:
    report["generated_at"] = datetime.utcnow().isoformat() + "Z"
    with open(output_file, "w", encoding="utf-8") as f:
        json.dump(report, f, indent=2)

data = {"workflow": "auditor", "status": "ok"}
save_report(data)

Now the script creates an artifact you can hand off, compare between runs, or feed into another tool.

Packaging pattern that improves conversion

I use the same packaging checklist for every utility product:

one ready-to-run script
README with exact commands
sample output so buyers know what they will get
short receipt text with quick-start instructions

That sounds basic, but it removes purchase friction and support overhead.

Why this matters for real projects

For small automation tools, trust beats novelty.
If a buyer can understand the workflow, run it quickly, and see useful output, adoption goes up.

The current packaged version of HackerNews Job Auditor is available here ($9.00):
https://intellitools.gumroad.com/l/hackernews-job-auditor

If you are building similar utilities, focus on repeatability and clarity first, then add more features.

Python Hackernews Playbook: Building HackerNews Job Exporter End to End (2026-05-11)

IntelliTools — Mon, 11 May 2026 19:26:07 +0000

Shipping reliable automation tools is mostly about reducing repeated manual work.

In this post I walk through a practical pattern I use to build and ship a focused utility: HackerNews Job Exporter.
The goal is simple: solve one painful workflow with a script a developer can run locally in minutes.

What problem this script solves

The approach is:

Make one script handle the core workflow.
Keep output deterministic and readable.
Package it with a README and sample output so anyone can run it quickly.

Minimal runnable structure

from pathlib import Path

def run_workflow(input_path: str) -> dict:
    text = Path(input_path).read_text(encoding="utf-8")
    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
    return {
        "line_count": len(lines),
        "char_count": len(text),
        "has_errors": any("error" in ln.lower() for ln in lines),
    }

print(run_workflow("sample_input.txt"))

This keeps the first pass intentionally small. You can run it instantly and verify the output before adding complexity.

Add a useful report layer

import json
from datetime import datetime

def save_report(report: dict, output_file: str = "report.json") -> None:
    report["generated_at"] = datetime.utcnow().isoformat() + "Z"
    with open(output_file, "w", encoding="utf-8") as f:
        json.dump(report, f, indent=2)

data = {"workflow": "exporter", "status": "ok"}
save_report(data)

Now the script creates an artifact you can hand off, compare between runs, or feed into another tool.

Packaging pattern that improves conversion

I use the same packaging checklist for every utility product:

one ready-to-run script
README with exact commands
sample output so buyers know what they will get
short receipt text with quick-start instructions

That sounds basic, but it removes purchase friction and support overhead.

Why this matters for real projects

For small automation tools, trust beats novelty.
If a buyer can understand the workflow, run it quickly, and see useful output, adoption goes up.

The current packaged version of HackerNews Job Exporter is available here ($7.00):
https://intellitools.gumroad.com/l/hackernews-job-exporter

If you are building similar utilities, focus on repeatability and clarity first, then add more features.

Python Exporter Playbook: Building HN Job Exporter End to End (2026-05-11)

IntelliTools — Mon, 11 May 2026 19:18:48 +0000

Shipping reliable automation tools is mostly about reducing repeated manual work.

In this post I walk through a practical pattern I use to build and ship a focused utility: HN Job Exporter.
The goal is simple: solve one painful workflow with a script a developer can run locally in minutes.

What problem this script solves

The approach is:

Make one script handle the core workflow.
Keep output deterministic and readable.
Package it with a README and sample output so anyone can run it quickly.

Minimal runnable structure

from pathlib import Path

def run_workflow(input_path: str) -> dict:
    text = Path(input_path).read_text(encoding="utf-8")
    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
    return {
        "line_count": len(lines),
        "char_count": len(text),
        "has_errors": any("error" in ln.lower() for ln in lines),
    }

print(run_workflow("sample_input.txt"))

This keeps the first pass intentionally small. You can run it instantly and verify the output before adding complexity.

Add a useful report layer

import json
from datetime import datetime

def save_report(report: dict, output_file: str = "report.json") -> None:
    report["generated_at"] = datetime.utcnow().isoformat() + "Z"
    with open(output_file, "w", encoding="utf-8") as f:
        json.dump(report, f, indent=2)

data = {"workflow": "strong", "status": "ok"}
save_report(data)

Now the script creates an artifact you can hand off, compare between runs, or feed into another tool.

Packaging pattern that improves conversion

I use the same packaging checklist for every utility product:

one ready-to-run script
README with exact commands
sample output so buyers know what they will get
short receipt text with quick-start instructions

That sounds basic, but it removes purchase friction and support overhead.

Why this matters for real projects

For small automation tools, trust beats novelty.
If a buyer can understand the workflow, run it quickly, and see useful output, adoption goes up.

The current packaged version of HN Job Exporter is available here ($7.00):
https://intellitools.gumroad.com/l/hn-job-exporter

If you are building similar utilities, focus on repeatability and clarity first, then add more features.

Python Exporter Playbook: Building HN Job Exporter End to End (2026-05-11)

IntelliTools — Mon, 11 May 2026 19:07:25 +0000

Shipping reliable automation tools is mostly about reducing repeated manual work.

What problem this script solves

The approach is:

Make one script handle the core workflow.
Keep output deterministic and readable.
Package it with a README and sample output so anyone can run it quickly.

Minimal runnable structure

from pathlib import Path

def run_workflow(input_path: str) -> dict:
    text = Path(input_path).read_text(encoding="utf-8")
    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
    return {
        "line_count": len(lines),
        "char_count": len(text),
        "has_errors": any("error" in ln.lower() for ln in lines),
    }

print(run_workflow("sample_input.txt"))

This keeps the first pass intentionally small. You can run it instantly and verify the output before adding complexity.

Add a useful report layer

import json
from datetime import datetime

def save_report(report: dict, output_file: str = "report.json") -> None:
    report["generated_at"] = datetime.utcnow().isoformat() + "Z"
    with open(output_file, "w", encoding="utf-8") as f:
        json.dump(report, f, indent=2)

data = {"workflow": "strong", "status": "ok"}
save_report(data)

Now the script creates an artifact you can hand off, compare between runs, or feed into another tool.

Packaging pattern that improves conversion

I use the same packaging checklist for every utility product:

one ready-to-run script
README with exact commands
sample output so buyers know what they will get
short receipt text with quick-start instructions

That sounds basic, but it removes purchase friction and support overhead.

Why this matters for real projects

For small automation tools, trust beats novelty.
If a buyer can understand the workflow, run it quickly, and see useful output, adoption goes up.

The current packaged version of HN Job Exporter is available here ($7.00):
https://intellitools.gumroad.com/l/hn-job-exporter

If you are building similar utilities, focus on repeatability and clarity first, then add more features.

Python Exporter Playbook: Building HN Job Exporter End to End (2026-05-11)

IntelliTools — Mon, 11 May 2026 18:51:43 +0000

Shipping reliable automation tools is mostly about reducing repeated manual work.

What problem this script solves

The approach is:

Make one script handle the core workflow.
Keep output deterministic and readable.
Package it with a README and sample output so anyone can run it quickly.

Minimal runnable structure

from pathlib import Path

def run_workflow(input_path: str) -> dict:
    text = Path(input_path).read_text(encoding="utf-8")
    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
    return {
        "line_count": len(lines),
        "char_count": len(text),
        "has_errors": any("error" in ln.lower() for ln in lines),
    }

print(run_workflow("sample_input.txt"))

This keeps the first pass intentionally small. You can run it instantly and verify the output before adding complexity.

Add a useful report layer

import json
from datetime import datetime

def save_report(report: dict, output_file: str = "report.json") -> None:
    report["generated_at"] = datetime.utcnow().isoformat() + "Z"
    with open(output_file, "w", encoding="utf-8") as f:
        json.dump(report, f, indent=2)

data = {"workflow": "strong", "status": "ok"}
save_report(data)

Now the script creates an artifact you can hand off, compare between runs, or feed into another tool.

Packaging pattern that improves conversion

I use the same packaging checklist for every utility product:

one ready-to-run script
README with exact commands
sample output so buyers know what they will get
short receipt text with quick-start instructions

That sounds basic, but it removes purchase friction and support overhead.

Why this matters for real projects

For small automation tools, trust beats novelty.
If a buyer can understand the workflow, run it quickly, and see useful output, adoption goes up.

The current packaged version of HN Job Exporter is available here ($7.00):
https://intellitools.gumroad.com/l/hn-job-exporter

If you are building similar utilities, focus on repeatability and clarity first, then add more features.

Automate Hacker News Job Tracking with Python Script

IntelliTools — Mon, 11 May 2026 18:41:38 +0000

import requests
from bs4 import BeautifulSoup
import csv

# Function to fetch Hacker News job postings
def fetch_hn_jobs():
    url = 'https://news.ycombinator.com/jobs'
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    jobs = []

    # Extract job entries
    for item in soup.select('.athing'):  # Select job posts
        title = item.select_one('.titlelink').text
        link = item.select_one('.titlelink')['href']
        company = item.select_one('.subtext .company').text.strip()
        role = item.select_one('.subtext .role').text.strip()
        location = item.select_one('.subtext .location').text.strip()
        jobs.append({
            'company': company,
            'role': role,
            'location': location,
            'link': link
        })

    return jobs

The fetch_hn_jobs function above demonstrates how to programmatically extract job postings from Hacker News. This script uses the requests and BeautifulSoup libraries to fetch and parse the HTML content. It then extracts key details like company, role, location, and link for each job posting. This eliminates the need for manual scraping and ensures data is captured consistently.

# Function to export jobs to CSV
def export_to_csv(jobs, filename='hn_jobs.csv'):
    with open(filename, 'w', newline='', encoding='utf-8') as csvfile:
        fieldnames = ['company', 'role', 'location', 'link']
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        writer.writeheader()
        for job in jobs:
            writer.writerow(job)

Once you've fetched the job data, the export_to_csv function writes it to a CSV file. This makes it easy to import into spreadsheet tools or job tracking systems. The script handles formatting and ensures the data is clean and structured for downstream use.

# Main execution block
if __name__ == '__main__':
    jobs = fetch_hn_jobs()
    export_to_csv(jobs)
    print(f"Exported {len(jobs)} job postings to 'hn_jobs.csv'")

This script is designed to be run as a standalone Python program. When executed, it fetches the latest Hacker News job postings, processes the data, and exports it to a CSV file. This automation saves time by eliminating the need for manual data entry or copy-paste workflows.

The script is built with real-world use cases in mind. It handles pagination and network errors automatically, ensuring that you get a complete and accurate dataset. This is particularly useful for remote developers and job seekers who want to track real-time job postings without spending hours manually scraping the site.

To get started, simply download the script and follow the setup instructions in the included README.txt. The script requires Python 3.7+ and the requests and beautifulsoup4 libraries, which can be installed with a single pip install command. The requirements.txt file ensures that all dependencies are managed efficiently.

For developers looking to streamline their job tracking process, this tool offers a practical and efficient solution. By automating the tracking of Hacker News job postings, you can focus more on your work and less on data collection. This script is a great example of how Python can be used to automate repetitive tasks and improve productivity.

If you're interested in learning more about how this script was built or want to try it out, you can find the full project at https://intellitools.gumroad.com/l/hn-job-exporter. This resource includes the complete Python script, setup instructions, and a sample output to help you get started quickly.

Python Hackernews Playbook: Building HackerNews Job Exporter End to End (2026-05-11)

IntelliTools — Mon, 11 May 2026 18:40:01 +0000

Shipping reliable automation tools is mostly about reducing repeated manual work.

What problem this script solves

The approach is:

Make one script handle the core workflow.
Keep output deterministic and readable.
Package it with a README and sample output so anyone can run it quickly.

Minimal runnable structure

from pathlib import Path

def run_workflow(input_path: str) -> dict:
    text = Path(input_path).read_text(encoding="utf-8")
    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
    return {
        "line_count": len(lines),
        "char_count": len(text),
        "has_errors": any("error" in ln.lower() for ln in lines),
    }

print(run_workflow("sample_input.txt"))

This keeps the first pass intentionally small. You can run it instantly and verify the output before adding complexity.

Add a useful report layer

import json
from datetime import datetime

def save_report(report: dict, output_file: str = "report.json") -> None:
    report["generated_at"] = datetime.utcnow().isoformat() + "Z"
    with open(output_file, "w", encoding="utf-8") as f:
        json.dump(report, f, indent=2)

data = {"workflow": "exporter", "status": "ok"}
save_report(data)

Now the script creates an artifact you can hand off, compare between runs, or feed into another tool.

Packaging pattern that improves conversion

I use the same packaging checklist for every utility product:

one ready-to-run script
README with exact commands
sample output so buyers know what they will get
short receipt text with quick-start instructions

That sounds basic, but it removes purchase friction and support overhead.

Why this matters for real projects

For small automation tools, trust beats novelty.
If a buyer can understand the workflow, run it quickly, and see useful output, adoption goes up.

The current packaged version of HackerNews Job Exporter is available here ($7.00):
https://intellitools.gumroad.com/l/hackernews-job-exporter

If you are building similar utilities, focus on repeatability and clarity first, then add more features.

Python Exporter Playbook: Building HN Job Exporter End to End (2026-05-11)

IntelliTools — Mon, 11 May 2026 18:27:34 +0000

Shipping reliable automation tools is mostly about reducing repeated manual work.

What problem this script solves

The approach is:

Make one script handle the core workflow.
Keep output deterministic and readable.
Package it with a README and sample output so anyone can run it quickly.

Minimal runnable structure

from pathlib import Path

def run_workflow(input_path: str) -> dict:
    text = Path(input_path).read_text(encoding="utf-8")
    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
    return {
        "line_count": len(lines),
        "char_count": len(text),
        "has_errors": any("error" in ln.lower() for ln in lines),
    }

print(run_workflow("sample_input.txt"))

This keeps the first pass intentionally small. You can run it instantly and verify the output before adding complexity.

Add a useful report layer

import json
from datetime import datetime

def save_report(report: dict, output_file: str = "report.json") -> None:
    report["generated_at"] = datetime.utcnow().isoformat() + "Z"
    with open(output_file, "w", encoding="utf-8") as f:
        json.dump(report, f, indent=2)

data = {"workflow": "strong", "status": "ok"}
save_report(data)

Now the script creates an artifact you can hand off, compare between runs, or feed into another tool.

Packaging pattern that improves conversion

I use the same packaging checklist for every utility product:

one ready-to-run script
README with exact commands
sample output so buyers know what they will get
short receipt text with quick-start instructions

That sounds basic, but it removes purchase friction and support overhead.

Why this matters for real projects

For small automation tools, trust beats novelty.
If a buyer can understand the workflow, run it quickly, and see useful output, adoption goes up.

The current packaged version of HN Job Exporter is available here ($7.00):
https://intellitools.gumroad.com/l/hn-job-exporter

If you are building similar utilities, focus on repeatability and clarity first, then add more features.

HN Job Exporter: Automate Hacker News Job Tracking with Python

IntelliTools — Mon, 11 May 2026 18:02:59 +0000

import requests
from bs4 import BeautifulSoup

# Fetch Hacker News job listings
url = 'https://news.ycombinator.com/jobs'
response = requests.get(url)

soup = BeautifulSoup(response.text, 'html.parser')
job_listings = soup.find_all('tr', class_='athing')

# Extract job details
jobs = []
for job in job_listings:
    title = job.find('span', class_='titleline').text.strip()
    link = job.find('a')['href']
    company = job.find('span', class_='company').text.strip()
    jobs.append({
        'title': title,
        'company': company,
        'link': link
    })

# Save to CSV
import csv
with open('hn_jobs.csv', 'w', newline='') as file:
    writer = csv.DictWriter(file, fieldnames=['title', 'company', 'link'])
    writer.writeheader()
    writer.writerows(jobs)

When you're looking for remote or freelance opportunities on Hacker News, manually copying job details is both time-consuming and error-prone. The HackerNews Job Exporter automates this process by fetching job listings directly from Hacker News and exporting them to a CSV file in one click. This tool is designed for Python developers who want to streamline their job tracking workflow without the hassle of manual copying.

The script uses requests to fetch the job listings page and BeautifulSoup to parse the HTML and extract relevant information. Each job listing is saved with its title, company, and link, and then exported to a CSV file. This approach ensures that you don't lose any job listings due to copy-paste errors or missed entries.

# Example of how to handle pagination
base_url = 'https://news.ycombinator.com/jobs?sort=desc&mode=job&points=100'
page = 1
all_jobs = []

while True:
    url = f'{base_url}?p={page}'
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    job_listings = soup.find_all('tr', class_='athing')

    if not job_listings:
        break

    for job in job_listings:
        # Extract job details as before
        all_jobs.extend(jobs)

    page += 1

The HackerNews Job Exporter handles pagination seamlessly, allowing you to export job listings from multiple pages without missing any data. This is especially useful when you're looking for opportunities across a large number of job listings. The script continues fetching jobs until there are no more entries, ensuring that you get a complete export of all available listings.

One of the key benefits of using the HackerNews Job Exporter is that it eliminates the need for manual copying. Instead of spending time copying and pasting job details, you can let the script do the work for you. This not only saves time but also reduces the risk of errors that can occur during manual data entry.

The tool includes all the necessary dependencies, and you can install them with a single pip install requests beautifulsoup4 command. The script is ready to run out of the box, and the included README.txt provides step-by-step instructions for setting up and running the tool. Additionally, a sample_output.txt file is provided to show exactly what the script produces, making it easy to understand the output format.

If you're a Python developer looking to automate your job tracking process, the HackerNews Job Exporter is the perfect tool for you. It allows you to focus on what matters most—finding the right remote or freelance opportunities—without the hassle of manual data entry. You can find the tool at https://intellitools.gumroad.com/l/hackernews-job-exporter.

Python Exporter Playbook: Building HN Job Exporter End to End (2026-05-11)

IntelliTools — Mon, 11 May 2026 17:42:19 +0000

Shipping reliable automation tools is mostly about reducing repeated manual work.

What problem this script solves

The approach is:

Make one script handle the core workflow.
Keep output deterministic and readable.
Package it with a README and sample output so anyone can run it quickly.

Minimal runnable structure

from pathlib import Path

def run_workflow(input_path: str) -> dict:
    text = Path(input_path).read_text(encoding="utf-8")
    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
    return {
        "line_count": len(lines),
        "char_count": len(text),
        "has_errors": any("error" in ln.lower() for ln in lines),
    }

print(run_workflow("sample_input.txt"))

This keeps the first pass intentionally small. You can run it instantly and verify the output before adding complexity.

Add a useful report layer

import json
from datetime import datetime

def save_report(report: dict, output_file: str = "report.json") -> None:
    report["generated_at"] = datetime.utcnow().isoformat() + "Z"
    with open(output_file, "w", encoding="utf-8") as f:
        json.dump(report, f, indent=2)

data = {"workflow": "strong", "status": "ok"}
save_report(data)

Now the script creates an artifact you can hand off, compare between runs, or feed into another tool.

Packaging pattern that improves conversion

I use the same packaging checklist for every utility product:

one ready-to-run script
README with exact commands
sample output so buyers know what they will get
short receipt text with quick-start instructions

That sounds basic, but it removes purchase friction and support overhead.

Why this matters for real projects

For small automation tools, trust beats novelty.
If a buyer can understand the workflow, run it quickly, and see useful output, adoption goes up.

The current packaged version of HN Job Exporter is available here ($7.00):
https://intellitools.gumroad.com/l/hn-job-exporter

If you are building similar utilities, focus on repeatability and clarity first, then add more features.

Python Exporter Playbook: Building HN Job Exporter End to End (2026-05-11)

IntelliTools — Mon, 11 May 2026 17:31:30 +0000

Shipping reliable automation tools is mostly about reducing repeated manual work.

What problem this script solves

The approach is:

Make one script handle the core workflow.
Keep output deterministic and readable.
Package it with a README and sample output so anyone can run it quickly.

Minimal runnable structure

from pathlib import Path

def run_workflow(input_path: str) -> dict:
    text = Path(input_path).read_text(encoding="utf-8")
    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
    return {
        "line_count": len(lines),
        "char_count": len(text),
        "has_errors": any("error" in ln.lower() for ln in lines),
    }

print(run_workflow("sample_input.txt"))

This keeps the first pass intentionally small. You can run it instantly and verify the output before adding complexity.

Add a useful report layer

import json
from datetime import datetime

def save_report(report: dict, output_file: str = "report.json") -> None:
    report["generated_at"] = datetime.utcnow().isoformat() + "Z"
    with open(output_file, "w", encoding="utf-8") as f:
        json.dump(report, f, indent=2)

data = {"workflow": "strong", "status": "ok"}
save_report(data)

Now the script creates an artifact you can hand off, compare between runs, or feed into another tool.

Packaging pattern that improves conversion

I use the same packaging checklist for every utility product:

one ready-to-run script
README with exact commands
sample output so buyers know what they will get
short receipt text with quick-start instructions

That sounds basic, but it removes purchase friction and support overhead.

Why this matters for real projects

For small automation tools, trust beats novelty.
If a buyer can understand the workflow, run it quickly, and see useful output, adoption goes up.

The current packaged version of HN Job Exporter is available here ($7.00):
https://intellitools.gumroad.com/l/hn-job-exporter

If you are building similar utilities, focus on repeatability and clarity first, then add more features.

How I Built a Python Workflow for HN Job Filter

IntelliTools — Mon, 11 May 2026 17:06:51 +0000

Shipping reliable automation tools is mostly about reducing repeated manual work.

In this post I walk through a practical pattern I use to build and ship a focused utility: HN Job Filter.
The goal is simple: solve one painful workflow with a script a developer can run locally in minutes.

What problem this script solves

The approach is:

Make one script handle the core workflow.
Keep output deterministic and readable.
Package it with a README and sample output so anyone can run it quickly.

Minimal runnable structure

from pathlib import Path

def run_workflow(input_path: str) -> dict:
    text = Path(input_path).read_text(encoding="utf-8")
    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
    return {
        "line_count": len(lines),
        "char_count": len(text),
        "has_errors": any("error" in ln.lower() for ln in lines),
    }

print(run_workflow("sample_input.txt"))

This keeps the first pass intentionally small. You can run it instantly and verify the output before adding complexity.

Add a useful report layer

import json
from datetime import datetime

def save_report(report: dict, output_file: str = "report.json") -> None:
    report["generated_at"] = datetime.utcnow().isoformat() + "Z"
    with open(output_file, "w", encoding="utf-8") as f:
        json.dump(report, f, indent=2)

data = {"workflow": "strong", "status": "ok"}
save_report(data)

Now the script creates an artifact you can hand off, compare between runs, or feed into another tool.

Packaging pattern that improves conversion

I use the same packaging checklist for every utility product:

one ready-to-run script
README with exact commands
sample output so buyers know what they will get
short receipt text with quick-start instructions

That sounds basic, but it removes purchase friction and support overhead.

Why this matters for real projects

For small automation tools, trust beats novelty.
If a buyer can understand the workflow, run it quickly, and see useful output, adoption goes up.

The current packaged version of HN Job Filter is available here ($7.00):
https://intellitools.gumroad.com/l/hn-job-filter

If you are building similar utilities, focus on repeatability and clarity first, then add more features.