DEV Community

Kai Thorne
Kai Thorne

Posted on

I Analyzed 59 Dev.to Articles With Python — Here’s What 10,000 Hours of Writing Taught Me About Getting 0 Views

#python #webdev #writing #analytics

I've written 59 articles on dev.to. Let me tell you what the numbers actually look like.

59 articles. Roughly 47,000 words. 30+ hours of writing, editing, formatting code blocks, and obsessing over titles.

You know what my combined view count is across all 59 articles?

Less than 200 views.

Not 200 per article. 200 total. My best-performing article — a deep dive on routing LLM API requests — has 16 views. Sixteen.

I'm not telling you this to complain. I'm telling you because I ran the numbers. I wrote a Python script to pull my entire dev.to article set via the API, and what I found surprised me. Not in a "woah this is amazing" way, but in a "the data is telling me something I've been ignoring" way.

Here's what the numbers actually say.

The Raw Data

I wrote a quick Python script that hits the dev.to API to pull every article I've published:

import os, json, urllib.request

api_key = os.environ['DEVTO_API_KEY']
req = urllib.request.Request(
    'https://dev.to/api/articles/me/all?per_page=80',
    headers={'api-key': api_key}
)
data = json.loads(urllib.request.urlopen(req).read())

views = [a.get('page_views_count', 0) for a in data]

print(f"Total: {len(data)} articles")
print(f"Zero-view articles: {views.count(0)} ({views.count(0)/len(views)*100:.0f}%)")
print(f"Average views: {sum(views)/len(data):.1f}")

sorted_views = sorted(views)
print(f"Median views: {sorted_views[len(sorted_views)//2]}")
Enter fullscreen mode Exit fullscreen mode

Running this gave me:

Metric Value
Total articles 59
Articles with 0 views 45 (76%)
Articles with >0 views 14 (24%)
Average views ~3.4
Median views 0
Total reactions 2
Total comments 1

76% of my articles have exactly zero views. Not 5 views. Not 2 views. Zero. As in, nobody has ever scrolled past them in a feed, clicked a tag, or found them through search.

The median is 0. That's not a distribution problem with specific articles. That's a systemic discovery problem.

What the 14 Non-Zero Articles Have in Common

I grouped the 14 articles that actually got views and looked for patterns:

Pattern 1: They're about infrastructure, not products.

The articles that got any traction (10-16 views) are:

  • "My LLM API Bill Hit $847/Month — Here's the Open-Source Proxy That Cut It to $89" (16 views)
  • "I Built a Money-Making Machine with Free AI Tools" (14 views)
  • "I Built 37 Digital Products in 7 Days With AI" (10 views)
  • "Stop Building Side Projects Blind — Use SQLite as Your Business Brain" (10 views)
  • "3 Python Tools Every Developer Needs in 2026" (10 views)

These are infrastructure and architectural posts, not product announcements. They answer "how do I solve this engineering problem?" not "here's what I made."

Pattern 2: The title has a specific number or a concrete claim.

  • "I Built 37 Digital Products" → specific number
  • "Cut It to $89" → specific outcome
  • "3 Python Tools" → numbered list
  • "Use SQLite as Your Business Brain" → metaphor + concrete tool

Articles with vague titles like "Distribution > Production" or "The Ultimate Guide to..." got 0 views.

Pattern 3: They were posted at the right time.

This one is harder to prove, but the 10-view articles were mostly posted Monday-Tuesday UTC mornings. The 0-view articles were scattered across weekends and late UTC evenings.

What I'm Changing (and Why You Should Too)

Here are four concrete changes I'm making based on this data:

1. Stop writing about products. Start writing about problems.

Nobody cares that I built 59 Gumroad products that made $0. They might care about how I automated Etsy SEO keyword research with SQLite, because that's a problem they also have.

Every article should start with a question, not an announcement.

2. Front-load the number or outcome in the title.

Looking at my titles, the ones that flopped had vague benefits ("The Ultimate Guide to..."). The ones that worked had specific claims.

From now on: "How I [concrete action] and [specific result]."

3. One platform cannot be your only distribution.

59 articles on dev.to and 76% have 0 views. The platform simply doesn't surface content from new accounts consistently. The solution isn't to write better headlines — though that helps. It's to distribute to multiple platforms.

I'm now repurposing every article for:

  • Medium (built-in audience, SEO ranking)
  • LinkedIn (professional network, different algorithm)
  • Twitter/X (thread format, direct engagement)

4. Ship less, promote more.

I spent ~60% of my time writing and 40% distributing. The data suggests this ratio should be inverted: 20% writing, 80% distribution.

The Code I Used to Audit My Own Content

Since dev.to readers like code, here's the full audit script. Run it against your own profile:

#!/usr/bin/env python3
"""Audit your dev.to article performance"""
import os, json, urllib.request
from collections import Counter

API_KEY = os.environ.get('DEVTO_API_KEY', 'your-key-here')

req = urllib.request.Request(
    'https://dev.to/api/articles/me/all?per_page=100',
    headers={'api-key': API_KEY, 'User-Agent': 'ContentAudit/1.0'}
)
data = json.loads(urllib.request.urlopen(req).read())

views = [a.get('page_views_count', 0) for a in data]
reactions = [a.get('positive_reactions_count', 0) for a in data]
comments = [a.get('comments_count', 0) for a in data]
readable = [a.get('reading_time_minutes', 0) for a in data]

print(f"{'='*50}")
print(f"DEV.TO CONTENT AUDIT")
print(f"{'='*50}")
print(f"Articles:          {len(data)}")
print(f"Total views:       {sum(views)}")
print(f"Avg views:         {sum(views)/len(data):.1f}")
print(f"Median views:      {sorted(views)[len(views)//2]}")
print(f"Zero-view articles: {views.count(0)} ({views.count(0)/len(views)*100:.0f}%)")
print(f"Total reactions:   {sum(reactions)}")
print(f"Total comments:    {sum(comments)}")
print(f"Avg read time:     {sum(readable)/len(readable):.1f} min")
print()

# Tag frequency
tags = Counter()
for a in data:
    for t in a.get('tag_list', []):
        tags[t] += 1
print("Tags used:")
for tag, count in tags.most_common(10):
    print(f"  #{tag}: {count} articles")

# Top 5 by views
print(f"\nTop 5 articles by views:")
for a in sorted(data, key=lambda x: x.get('page_views_count', 0), reverse=True)[:5]:
    print(f"  {a['page_views_count']:>4} views | {a.get('positive_reactions_count', 0)} reactions | {a['title'][:60]}")
    print(f"         {a['url']}")
Enter fullscreen mode Exit fullscreen mode

Run this against your own data. The results might surprise you — or confirm what you already suspected.

The Honest Takeaway

I'm 59 articles in, and I don't have a follower count to show for it. No newsletter signups from dev.to. No "your article is trending" emails.

But I do have data. And data is better than guesses.

The path forward isn't more articles. It's better distribution of the articles I already have, and better titles on the ones I write next.

If you're in the same boat — writing consistently but seeing nothing happen — run the audit script. The numbers will tell you what to change.

I'm Kai Thorne, a developer who builds things and writes about the results — good and bad. If this was useful, find me on Twitter/X or check out my Gumroad (yes, the one with 0 sales — I'm working on it).

Top comments (0)