Claude vs DeepSeek for coding

Every limit is published. Paid plans also have a monthly fair-use limit on AI cost: Pro $7.50, Max $20, Ultra $42, Studio $85. Using every message on your plan at typical sizes stays under it; very large messages and heavy research use it faster. Every limit, explained.

Coding: Claude Haiku 5.5 passed 5 of 5 and DeepSeek V4.1 Flash 5 of 5. DeepSeek V4.1 Flash answered 1.6× sooner at the median, 3.9 s against 2.5 s. Claude Haiku 5.5 cost 4.1× less, $0.0023 against $0.0092 for the 5 replies. Their replies ran to about the same length.

1. 1. Turn a title into a URL slug

   Everyday. Claude: 6 of 6 models passed, Claude Haiku 5.5 the cheapest at $0.0001 · DeepSeek: 2 of 2 models passed, DeepSeek V4.1 Flash the cheapest at $0.0004. The prompt in full.

   Claude Haiku 5.5 and DeepSeek V4.1 Flash both passed this one. DeepSeek V4.1 Flash answered sooner (1.3 s to 1.5 s), and Claude Haiku 5.5's reply cost less ($0.0001 to $0.0004); Claude Haiku 5.5 wrote 112 tokens of reply, DeepSeek V4.1 Flash 253.

   • Claude Haiku 5.5

     Passed: All 7 tests passed.

     ```javascript
     function slugify(title) {
       return String(title)
         .normalize("NFD")
         .replace(/[\u0300-\u036f]/g, "")
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "");
     }
     ```

     672 tokens in, 112 out · 1.5 s · $0.0001 · 1 message on Pro · answered by anthropic/claude-haiku-5.5 via Anthropic · October 7, 2026

   • DeepSeek V4.1 Flash

     Passed: All 7 tests passed.

     ```javascript
     function slugify(title) {
       return title
         .normalize('NFD')            // split accented letters into base + combining mark
         .replace(/[\u0300-\u036f]/g, '') // drop the combining marks (é → e, ñ → n, ü → u)
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, '-')  // every run of anything else becomes one hyphen
         .replace(/^-+|-+$/g, '');     // trim leading/trailing hyphens
     }
     ```
     
     Note: `normalize('NFD')` handles the accents, but a few letters don't decompose that way (`ø`, `ß`, `đ`, `æ`). If you need those, add an explicit map before the cleanup:
     
     ```javascript
     const SPECIAL = { ø: 'o', ß: 'ss', đ: 'd', æ: 'ae', œ: 'oe', þ: 'th', ł: 'l' };
     ```
     
     with `title.replace(/[øßđæœþł]/gi, c => SPECIAL[c.toLowerCase()])` inserted before `.toLowerCase()`.

     522 tokens in, 276 out (23 of them reasoning) · 1.3 s · $0.0004 · 1 message on Pro · answered by deepseek/deepseek-v4.1-flash via Together · October 7, 2026

2. 2. Parse a duration like “1h 30m”

   Everyday. Claude: 6 of 6 models passed, Claude Haiku 5.5 the cheapest at $0.0005 · DeepSeek: 2 of 2 models passed, DeepSeek V4.1 Flash the cheapest at $0.0011. The prompt in full.

   Claude Haiku 5.5 and DeepSeek V4.1 Flash both passed this one. DeepSeek V4.1 Flash answered sooner (2.5 s to 5.4 s), and Claude Haiku 5.5's reply cost less ($0.0005 to $0.0011); Claude Haiku 5.5 wrote 180 tokens of reply, DeepSeek V4.1 Flash 144.

   • Claude Haiku 5.5

     Passed: All 10 tests passed.

     ```javascript
     function parseDuration(text) {
       if (typeof text !== 'string') return null;
     
       const m = /^\s*(?:(\d+)h)?\s*(?:(\d+)m)?\s*(?:(\d+)s)?\s*$/.exec(text);
       if (!m || m.slice(1).every(v => v === undefined)) return null;
     
       const [, h = 0, mi = 0, s = 0] = m;
       return Number(h) * 3600 + Number(mi) * 60 + Number(s);
     }
     ```

     627 tokens in, 868 out (688 of them reasoning) · 5.4 s · $0.0005 · 1 message on Pro · answered by anthropic/claude-haiku-5.5 via Anthropic · October 7, 2026

   • DeepSeek V4.1 Flash

     Passed: All 10 tests passed.

     ```javascript
     function parseDuration(text) {
       if (typeof text !== 'string') return null;
       const match = /^\s*(?:(\d+)h)?\s*(?:(\d+)m)?\s*(?:(\d+)s)?\s*$/.exec(text);
       if (!match) return null;
       const [, h, m, s] = match;
       if (h === undefined && m === undefined && s === undefined) return null;
       return (h ? Number(h) * 3600 : 0) + (m ? Number(m) * 60 : 0) + (s ? Number(s) : 0);
     }
     ```

     505 tokens in, 890 out (746 of them reasoning) · 2.5 s · $0.0011 · 1 message on Pro · answered by deepseek/deepseek-v4.1-flash via Together · October 7, 2026

3. 3. Merge overlapping intervals

   Everyday. Claude: 6 of 6 models passed, Claude Haiku 5.5 the cheapest at $0.0002 · DeepSeek: 2 of 2 models passed, DeepSeek V4.1 Flash the cheapest at $0.0003. The prompt in full.

   Claude Haiku 5.5 and DeepSeek V4.1 Flash both passed this one. DeepSeek V4.1 Flash answered sooner (0.6 s to 1.3 s), and Claude Haiku 5.5's reply cost less ($0.0002 to $0.0003); Claude Haiku 5.5 wrote 185 tokens of reply, DeepSeek V4.1 Flash 210.

   • Claude Haiku 5.5

     Passed: All 7 tests passed.

     ```javascript
     function mergeIntervals(intervals) {
       const sorted = intervals
         .map(([start, end]) => [start, end])
         .sort((a, b) => a[0] - b[0] || a[1] - b[1]);
     
       const merged = [];
       for (const [start, end] of sorted) {
         const last = merged[merged.length - 1];
         if (last && start <= last[1]) {
           last[1] = Math.max(last[1], end);
         } else {
           merged.push([start, end]);
         }
       }
       return merged;
     }
     ```

     622 tokens in, 185 out · 1.3 s · $0.0002 · 1 message on Pro · answered by anthropic/claude-haiku-5.5 via Anthropic · October 7, 2026

   • DeepSeek V4.1 Flash

     Passed: All 7 tests passed.

     ```javascript
     function mergeIntervals(intervals) {
       if (!Array.isArray(intervals) || intervals.length === 0) return [];
     
       // Copy each pair so the input array (and its pairs) are never mutated.
       const sorted = intervals
         .map(([start, end]) => [start, end])
         .sort((a, b) => a[0] - b[0] || a[1] - b[1]);
     
       const merged = [sorted[0]];
     
       for (let i = 1; i < sorted.length; i++) {
         const [start, end] = sorted[i];
         const last = merged[merged.length - 1];
     
         if (start <= last[1]) {
           // Overlapping or touching: extend the current interval.
           if (end > last[1]) last[1] = end;
         } else {
           merged.push([start, end]);
         }
       }
     
       return merged;
     }
     ```

     489 tokens in, 216 out (6 of them reasoning) · 0.6 s · $0.0003 · 1 message on Pro · answered by deepseek/deepseek-v4.1-flash via Together · October 8, 2026

4. 4. Evaluate an arithmetic expression, no eval

   Hard. Claude: 5 of 6 models passed, Claude Haiku 5.5 the cheapest at $0.0006 · DeepSeek: 2 of 2 models passed, DeepSeek V4.1 Flash the cheapest at $0.0030. The prompt in full.

   Claude Haiku 5.5 and DeepSeek V4.1 Flash both passed this one. Claude Haiku 5.5 answered sooner (3.9 s to 5.8 s), and Claude Haiku 5.5's reply cost less ($0.0006 to $0.0030); Claude Haiku 5.5 wrote 1,074 tokens of reply, DeepSeek V4.1 Flash 951.

   • Claude Haiku 5.5

     Passed: All 15 tests passed.

     ```javascript
     function evaluate(expression) {
       const s = String(expression);
       const tokens = [];
       let i = 0;
       while (i < s.length) {
         const c = s[i];
         if (c === ' ' || c === '\t' || c === '\n' || c === '\r') { i++; continue; }
         if ((c >= '0' && c <= '9') || c === '.') {
           let j = i;
           while (j < s.length && ((s[j] >= '0' && s[j] <= '9') || s[j] === '.')) j++;
           const text = s.slice(i, j);
           if (!/^(\d+\.?\d*|\.\d+)$/.test(text)) throw new Error(`Invalid number "${text}"`);
           tokens.push({ type: 'num', value: Number(text) });
           i = j;
           continue;
         }
         if ('+-*/^()'.includes(c)) {
           tokens.push({ type: c });
           i++;
           continue;
         }
         throw new Error(`Unexpected character "${c}"`);
       }
     
       let pos = 0;
       const peek = () => tokens[pos] ? tokens[pos].type : null;
       const next = () => tokens[pos++];
     
       // expr := term (('+'|'-') term)*
       function parseExpr() {
         let value = parseTerm();
         while (peek() === '+' || peek() === '-') {
           const op = next().type;
           const rhs = parseTerm();
           value = op === '+' ? value + rhs : value - rhs;
         }
         return value;
       }
     
       // term := unary (('*'|'/') unary)*
       function parseTerm() {
         let value = parseUnary();
         while (peek() === '*' || peek() === '/') {
           const op = next().type;
           const rhs = parseUnary();
           value = op === '*' ? value * rhs : value / rhs;
         }
         return value;
       }
     
       // unary := '-' unary | power
       function parseUnary() {
         if (peek() === '-') {
           next();
           return -parseUnary();
         }
         return parsePower();
       }
     
       // power := primary ('^' unary)?   (right-associative; exponent may be signed)
       function parsePower() {
         const base = parsePrimary();
         if (peek() === '^') {
           next();
           const exp = parseUnary();
           return Math.pow(base, exp);
         }
         return base;
       }
     
       // primary := number | '(' expr ')'
       function parsePrimary() {
         const t = tokens[pos];
         if (!t) throw new Error('Unexpected end of expression');
         if (t.type === 'num') {
           pos++;
           return t.value;
         }
         if (t.type === '(') {
           pos++;
           const value = parseExpr();
           if (peek() !== ')') throw new Error('Expected ")"');
           pos++;
           return value;
         }
         throw new Error(`Unexpected token "${t.type}"`);
       }
     
       if (tokens.length === 0) throw new Error('Empty expression');
       const result = parseExpr();
       if (pos !== tokens.length) throw new Error(`Unexpected token "${tokens[pos].type}"`);
       return result;
     }
     ```

     763 tokens in, 1,074 out · 3.9 s · $0.0006 · 1 message on Pro · answered by anthropic/claude-haiku-5.5 via Anthropic · October 7, 2026

   • DeepSeek V4.1 Flash

     Passed: All 15 tests passed.

     ```javascript
     function evaluate(expression) {
       if (typeof expression !== 'string') {
         throw new Error('Expression must be a string');
       }
     
       // ---- Tokenizer ----
       const tokens = [];
       let i = 0;
       const isDigit = (c) => c >= '0' && c <= '9';
     
       while (i < expression.length) {
         const ch = expression[i];
     
         if (ch === ' ' || ch === '\t') {
           i++;
           continue;
         }
     
         // number: digits with an optional single decimal point (at least one digit)
         if (isDigit(ch) || ch === '.') {
           let j = i;
           let digits = 0;
           while (j < expression.length && isDigit(expression[j])) {
             j++;
             digits++;
           }
           if (j < expression.length && expression[j] === '.') {
             j++;
             while (j < expression.length && isDigit(expression[j])) {
               j++;
               digits++;
             }
           }
           if (digits === 0) {
             throw new Error('Invalid number in expression');
           }
           tokens.push({ type: 'num', value: parseFloat(expression.slice(i, j)) });
           i = j;
           continue;
         }
     
         if ('+-*/^()'.indexOf(ch) !== -1) {
           tokens.push({ type: ch });
           i++;
           continue;
         }
     
         throw new Error('Unexpected character: ' + ch);
       }
     
       if (tokens.length === 0) {
         throw new Error('Empty expression');
       }
     
       // ---- Parser (recursive descent) ----
       let pos = 0;
       const peek = () => tokens[pos];
       const isOp = (tok, ch) => tok !== undefined && tok.type === ch;
     
       // expr := term (('+' | '-') term)*          left-associative
       function parseExpression() {
         let value = parseTerm();
         while (isOp(peek(), '+') || isOp(peek(), '-')) {
           const op = tokens[pos++].type;
           const rhs = parseTerm();
           value = op === '+' ? value + rhs : value - rhs;
         }
         return value;
       }
     
       // term := unary (('*' | '/') unary)*        left-associative
       function parseTerm() {
         let value = parseUnary();
         while (isOp(peek(), '*') || isOp(peek(), '/')) {
           const op = tokens[pos++].type;
           const rhs = parseUnary();
           value = op === '*' ? value * rhs : value / rhs;
         }
         return value;
       }
     
       // unary := ('-' | '+') unary | power
       // unary minus is looser than '^', so -2^2 === -(2^2) === -4
       function parseUnary() {
         if (isOp(peek(), '-')) {
           pos++;
           return -parseUnary();
         }
         if (isOp(peek(), '+')) {
           pos++;
           return parseUnary();
         }
         return parsePower();
       }
     
       // power := primary ('^' unary)?             right-associative
       // the exponent is a unary, which permits 2^-1 and 2^3^2 = 2^(3^2)
       function parsePower() {
         const base = parsePrimary();
         if (isOp(peek(), '^')) {
           pos++;
           const exponent = parseUnary();
           return Math.pow(base, exponent);
         }
         return base;
       }
     
       // primary := number | '(' expr ')'
       function parsePrimary() {
         const tok = peek();
         if (tok === undefined) {
           throw new Error('Unexpected end of expression');
         }
         if (tok.type === 'num') {
           pos++;
           return tok.value;
         }
         if (tok.type === '(') {
           pos++;
           const value = parseExpression();
           if (!isOp(peek(), ')')) {
             throw new Error('Missing closing parenthesis');
           }
           pos++;
           return value;
         }
         throw new Error('Unexpected token: ' + tok.type);
       }
     
       const result = parseExpression();
       if (pos !== tokens.length) {
         throw new Error('Unexpected token: ' + tokens[pos].type);
       }
       return result;
     }
     ```

     591 tokens in, 2,442 out (1,491 of them reasoning) · 5.8 s · $0.0030 · 1 message on Pro · answered by deepseek/deepseek-v4.1-flash via Together · October 8, 2026

5. 5. Parse CSV with quoted fields

   Hard. Claude: 5 of 6 models passed, Claude Haiku 5.5 the cheapest at $0.0008 · DeepSeek: 2 of 2 models passed, DeepSeek V4.1 Flash the cheapest at $0.0042. The prompt in full.

   Claude Haiku 5.5 and DeepSeek V4.1 Flash both passed this one. Claude Haiku 5.5 answered sooner (8.1 s to 9.1 s), and Claude Haiku 5.5's reply cost less ($0.0008 to $0.0042); Claude Haiku 5.5 wrote 516 tokens of reply, DeepSeek V4.1 Flash 399.

   • Claude Haiku 5.5

     Passed: All 8 tests passed.

     ```javascript
     function parseCsv(text) {
       const rows = [];
       if (text === '') return rows;
     
       let row = [];
       let field = '';
       let inQuotes = false;
       let fieldStart = true; // true only at the very beginning of a field
       let i = 0;
       const n = text.length;
     
       while (i < n) {
         const c = text[i];
     
         if (inQuotes) {
           if (c === '"') {
             if (text[i + 1] === '"') {
               field += '"';
               i += 2;
             } else {
               inQuotes = false;
               i++;
             }
           } else {
             field += c;
             i++;
           }
           continue;
         }
     
         if (c === '"' && fieldStart) {
           inQuotes = true;
           fieldStart = false;
           i++;
           continue;
         }
     
         if (c === ',') {
           row.push(field);
           field = '';
           fieldStart = true;
           i++;
           continue;
         }
     
         if (c === '\n' || c === '\r') {
           row.push(field);
           rows.push(row);
           row = [];
           field = '';
           fieldStart = true;
           if (c === '\r' && text[i + 1] === '\n') i += 2;
           else i++;
           continue;
         }
     
         field += c;
         fieldStart = false;
         i++;
       }
     
       // Flush the last row unless the text ended with a line break
       if (row.length > 0 || field !== '' || !fieldStart) {
         row.push(field);
         rows.push(row);
       }
     
       return rows;
     }
     ```

     670 tokens in, 1,464 out (948 of them reasoning) · 8.1 s · $0.0008 · 1 message on Pro · answered by anthropic/claude-haiku-5.5 via Anthropic · October 7, 2026

   • DeepSeek V4.1 Flash

     Passed: All 8 tests passed.

     ```javascript
     function parseCsv(text) {
       const rows = [];
       let row = [];
       let field = '';
       let inQuotes = false;
       let pending = false; // true if there is an in-progress field/row
       let i = 0;
       const n = text.length;
     
       while (i < n) {
         const ch = text[i];
     
         if (inQuotes) {
           if (ch === '"') {
             if (text[i + 1] === '"') {
               field += '"';
               i += 2;
             } else {
               inQuotes = false;
               i += 1;
             }
           } else {
             field += ch;
             i += 1;
           }
           continue;
         }
     
         if (ch === '"' && field === '') {
           // A quote only opens a quoted field when it is the first char of the field.
           inQuotes = true;
           pending = true;
           i += 1;
           continue;
         }
     
         if (ch === ',') {
           row.push(field);
           field = '';
           pending = true;
           i += 1;
           continue;
         }
     
         if (ch === '\n' || ch === '\r') {
           if (ch === '\r' && text[i + 1] === '\n') i += 1; // treat CRLF as one break
           row.push(field);
           rows.push(row);
           row = [];
           field = '';
           pending = false;
           i += 1;
           continue;
         }
     
         field += ch;
         pending = true;
         i += 1;
       }
     
       // A line break at the very end leaves "pending" false, so no empty trailing row.
       if (pending) {
         row.push(field);
         rows.push(row);
       }
     
       return rows;
     }
     ```

     522 tokens in, 3,473 out (3,074 of them reasoning) · 9.1 s · $0.0042 · 1 message on Pro · answered by deepseek/deepseek-v4.1-flash via Together · October 8, 2026

• Claude Fable 5.1 vs DeepSeek V4 Pro: 5 of 5 each; Claude Fable 5.1 answered 21.6× sooner at the median and DeepSeek V4 Pro cost 1.8× less.

• Claude Fable 5.1 vs DeepSeek V4.1 Flash: 5 of 5 each; DeepSeek V4.1 Flash answered 2.2× sooner at the median and cost 23.2× less.

• Claude Opus 5.5 vs DeepSeek V4 Pro: 5 of 5 each; Claude Opus 5.5 answered 16.6× sooner at the median and cost 1.4× less. Claude Opus 5.5 vs DeepSeek V4 Pro, on every job.

• Claude Opus 5.5 vs DeepSeek V4.1 Flash: 5 of 5 each; DeepSeek V4.1 Flash answered 2.9× sooner at the median and cost 9.3× less.

• Claude Sonnet 5.5 vs DeepSeek V4 Pro: 5 of 5 each; Claude Sonnet 5.5 answered 61.0× sooner at the median and cost 3.8× less.

• Claude Sonnet 5.5 vs DeepSeek V4.1 Flash: 5 of 5 each; Claude Sonnet 5.5 answered 1.3× sooner at the median and DeepSeek V4.1 Flash cost 3.4× less.

• Claude Sonnet 5 vs DeepSeek V4 Pro: 5 of 5 each; Claude Sonnet 5 answered 44.8× sooner at the median and cost 2.4× less. Claude Sonnet 5 vs DeepSeek V4 Pro, on every job.

• Claude Sonnet 5 vs DeepSeek V4.1 Flash: 5 of 5 each; they took about as long and DeepSeek V4.1 Flash cost 5.5× less.

• Claude Haiku 4.5 vs DeepSeek V4 Pro: Claude Haiku 4.5 3 of 5, DeepSeek V4 Pro 5; Claude Haiku 4.5 answered 51.0× sooner at the median and cost 8.7× less. Claude Haiku 4.5 vs DeepSeek V4 Pro, on every job.

• Claude Haiku 4.5 vs DeepSeek V4.1 Flash: Claude Haiku 4.5 3 of 5, DeepSeek V4.1 Flash 5; they took about as long and DeepSeek V4.1 Flash cost 1.5× less. Claude Haiku 4.5 vs DeepSeek V4.1 Flash, on every job.

• Claude Haiku 5.5 vs DeepSeek V4 Pro: 5 of 5 each; Claude Haiku 5.5 answered 30.3× sooner at the median and cost 53.0× less.

• Claude Haiku 5.5 vs DeepSeek V4.1 Flash: 5 of 5 each; DeepSeek V4.1 Flash answered 1.6× sooner at the median and Claude Haiku 5.5 cost 4.1× less. Claude Haiku 5.5 vs DeepSeek V4.1 Flash, on every job.

Every Claude and DeepSeek reply above was checked the same way as every other model's, by the rules published with the prompts: how the coding prompts are scored, and each one in full.

• The lineups

  Claude: 6 models, Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5, Claude Sonnet 5, Claude Haiku 4.5, and Claude Haiku 5.5. DeepSeek: 2 models, DeepSeek V4 Pro and DeepSeek V4.1 Flash.

• Price per message

  The least expensive Claude model is Claude Haiku 5.5 (60 messages a day on Pro); the least expensive DeepSeek model is DeepSeek V4.1 Flash (60 messages a day on Pro).

• Context window

  Claude goes up to 1M tokens (Claude Fable 5.1); DeepSeek up to 1.05M tokens (DeepSeek V4 Pro).

• Images and PDFs

  DeepSeek V4 Pro doesn't read images. DeepSeek V4 Pro and DeepSeek V4.1 Flash get a PDF's text rather than the file itself.

• On the Free plan

  Free's one-time trial of 5 messages covers Claude Sonnet 5.5, Claude Sonnet 5, Claude Haiku 4.5, Claude Haiku 5.5, DeepSeek V4 Pro, and DeepSeek V4.1 Flash, and Claude Opus 5.5 for 1 message. Paid plans have every model, with messages every month.

In llmwise, a message to Claude goes to its maker, Anthropic, or through OpenRouter when llmwise can't reach the maker directly. DeepSeek models are served only through OpenRouter, by endpoints that don't store or train on prompts. The Privacy Policy has the details.