Software development is changing fast these days, with AI assistants now an integral part of many developers' workflows. According to Stack Overflow's 2024 survey, 63% of professional developers report using AI tools in their development process. This surge is fueled by advanced models that can write, review, and even explain code. Industry leaders have declared that "English is emerging as the universal coding language" thanks to AI, reflecting the idea that natural language prompts can replace traditional syntax. Concepts like "vibe coding" – where one "fully gives in to the vibes, embraces exponentials, and forgets that the code even exists" – have entered the lexicon, illustrating the new, fluid relationship between human intent and code. Alongside code generation, AI-assisted code review is an emerging trend: We @entelligence.ai use LLMs to automate pull-request reviews and catch bugs early. Today, we are comparing two powerful LLMs – DeepSeek R1 and Qwen 3 – on a suite of coding problems to see how they stack up in real-world coding tasks, and discuss the broader implications for AI-driven development.

Overview of the Models

DeepSeek R1 is a massive mixture-of-experts model (≈671B total parameters, 37B activated per token) from Chinese AI-Lab DeepSeek, developed with a focus on reasoning. It was trained with multi-stage reinforcement learning (RL) to explore chain-of-thought strategies. DeepSeek-R1's designers report that it "achieves performance comparable to OpenAI-o1 across math, code, and reasoning tasks", highlighting its strength in logic and problem-solving. The model is open-source, and distilled smaller versions (e.g. based on Qwen or Llama) have been released. In practice, DeepSeek R1 excels at generating detailed reasoning chains and handling complex logic, and Entelligence's benchmarks suggest it has strong code-understanding capabilities (see below).

Qwen 3 is Alibaba's latest family of LLMs, ranging from tiny (0.6B) to very large (235B parameters) models, including both dense and Mixture-of-Experts variants. Like DeepSeek, Qwen 3 uses MoE techniques (the 235B "A22B" model activates ~22B parameters per forward pass) and is open-weight and multilingual. Crucially, Qwen 3 includes specialized coding models: for example, Alibaba reports that its flagship Qwen3-235B model "achieves competitive results in benchmark evaluations of coding, math [and] general [tasks]". Independent reports note that even the mid-sized 32B Qwen 3 coding model "matches GPT-4o's coding prowess" with high accuracy. In fact, some analyses (e.g. from Entelligence) claim Qwen 3 variants outperform models like DeepSeek R1 and GPT-4 on standard benchmarks. In summary, Qwen 3 is a versatile, high-performance LLM suite with strong credentials in code generation and reasoning.

Both models are state-of-the-art and open-source, but they have different strengths: DeepSeek R1 emphasizes RL-trained reasoning patterns, while Qwen 3 emphasizes scalable performance and coding fluency. In the sections below we compare how each model tackles five practical coding problems.

Benchmark Coding Tasks

We evaluated both models on five coding challenges of increasing complexity:

1. Asynchronous Web Scraper: Build a web scraper using asyncio and aiohttp to fetch multiple pages concurrently (with rate limiting) and save results to a database.

2. Topological Sort: Given a list of tasks and dependencies (a directed acyclic graph), produce an order that respects all prerequisites (i.e. topological sort).

3. SaaS Landing Page: Create a modern-looking SaaS landing page for an AI code review company (HTML/CSS/JS, responsive design).

4. Rainbow SVG Bird: Draw a stylized flying bird in rainbow colors using SVG.

5. Animated Weather Card: Build a colorful, animated weather card (HTML/CSS/JS) that displays current conditions (e.g. temperature, sun/rain/cloud icons, wind speed).

For each task we present the model outputs (abridged for clarity), discuss the approaches, and judge which model handled it better.

Task 1: Asynchronous Web Scraper

Q1: Build a web scraper using asyncio and aiohttp that can concurrently scrape multiple pages, respecting rate limits, and saving the results to a database.

Description: Scrape multiple web pages concurrently using asyncio/aiohttp, enforce a rate limit, and store each page's title in a database.

Qwen 3's Solution:

Qwen 3 generated a concise Python scraper. It uses asyncio.Semaphore to limit concurrency, an aiohttp.TCPConnector(limit_per_host=2) for per-domain connection limits, and a simple re regex to extract the <title>. It also uses aiosqlite for async DB writes.

Here's a complete and well-structured implementation of a concurrent web scraper using asyncio, aiohttp, and aiosqlite that respects rate limits and stores the scraped data into a SQLite database.

✅ Features Implemented

• Asynchronous scraping with aiohttp.

• Concurrency control using asyncio.Semaphore.

• Rate limiting per request with a configurable delay.

• Per-domain connection limits via TCPConnector.

• Async database writes using aiosqlite.

📁 Project Structure

🧠 Key Concepts Used

• async/await: For non-blocking I/O.

• Semaphore: To limit the number of concurrent requests.

• TCPConnector(limit_per_host=...): To avoid hammering a single host.

• aiosqlite: For asynchronous SQLite database writes.

• Regex: For simple title extraction from HTML (can be replaced with BeautifulSoup in a thread pool if needed).

🧾 Full Code (scraper.py)

🛠️ How It Works

1. Database Initialization: Creates a SQLite table scraped_pages if it doesn't exist.

2. Concurrency Control: Uses Semaphore to limit the number of simultaneous requests.

3. Rate Limiting: Adds a small delay (RATE_LIMIT_DELAY) after each request to avoid overwhelming servers.

4. Per-Host Connection Limits: TCPConnector(limit_per_host=2) ensures no more than 2 concurrent requests per domain.

5. HTML Parsing: Uses a simple regex to extract the <title> tag from the HTML.

6. Error Handling: Catches exceptions during scraping and logs errors without crashing the entire process.

📦 Requirements

Install the necessary libraries:

🧪 Example Output

📚 Notes

• For real-world use, consider replacing regex with BeautifulSoup inside an asyncio.to_thread() for parsing HTML.

• You can extend this to respect robots.txt and respect Crawl-Delay directives.

• For production, use a more robust database like PostgreSQL with asyncpg.

📌 Summary

This scraper efficiently scrapes multiple pages concurrently, respects server limits, and stores the results in a SQLite database—all using asynchronous Python. It's modular, scalable, and ready to be extended with advanced features like proxy rotation, retries, or request throttling.

Output:

This code sets up the database table, then in main() it creates an aiohttp.ClientSession with a TCPConnector(limit_per_host=2). It kicks off asynchronous fetch() tasks for all URLs and waits for them with asyncio.gather(). The scraper is modular and covers basic error handling and cleanup.

DeepSeek R1's Solution:

DeepSeek R1's output is more elaborate. It likewise uses asyncio, aiohttp, and aiosqlite, but adds extra robustness. It imports BeautifulSoup (bs4) to parse HTML (instead of regex), includes retry logic with timeouts, and structures the code into helper functions (create_table, save_to_db, etc.). Important excerpts:

Here's a complete implementation of an async web scraper using asyncio, aiohttp, and aiosqlite that handles concurrency, rate limiting, and database storage:

Key features of this implementation:

1. Rate Limiting: Uses a token bucket algorithm to enforce rate limits

2. Concurrency: Uses multiple workers to process URLs concurrently

3. Retry Logic: Implements exponential backoff for failed requests

4. Database Storage: Stores results in SQLite with async operations

5. Error Handling: Robust error handling with retries and proper cleanup

6. HTML Parsing: Uses BeautifulSoup for content extraction

To use this scraper:

1. Install required packages:

2. Modify the sample_urls list with your target URLs

3. Run the script:

The scraper will:

• Process URLs concurrently while respecting rate limits

• Store results in an SQLite database (scraped_data.db)

• Retry failed requests with exponential backoff

• Handle network errors and timeouts gracefully

Note: Always check website's robots.txt and terms of service before scraping, and consider adding proper user-agent headers and request delays to be respectful of target servers.

Output: