DEV Community: Oluwawunmi Adesewa

How to Activate Claude Skills Automatically: 2 Fixes for 95% Activation

Oluwawunmi Adesewa — Fri, 20 Feb 2026 04:12:57 +0000

The point of Claude Skills in Claude Code is autonomous skill activation. You define a skill and Claude automatically triggers it when relevant.

But if you've actually tried building with Skills, you know that's not how it behaves by default.

They don't trigger consistently. Even when the trigger conditions look correct, Claude often ignores them.

While you can use workarounds like slash commands or stacking rules in the CLAUDE.md file, these methods lose the core benefit: skills firing on their own.

If you want to make Claude Code skills activate automatically instead of calling them yourself, this tutorial shows exactly how to set them up so they fire reliably.

Why Claude Skills Don't Trigger
Fix 1: Detection Hook + Trigger Rules
- What we Need the Skill to do
- What We Need to Install
- Step 1
- Step 2: Create the Hook Files
- Step 2: Configure Skill Triggers
- Step 3: Activate the Hook
- How It Works
Fix 2: Forced Skill Evaluation
- How Forced Skill Evaluation Works
- How to Set it up
Bonus: Settings Tweak Worth Testing
Which Method Should You Use?
- Use Detection Hook (Fix 1) when:
- Use Forced Evaluation (Fix 2) when:
- Use Custom Instructions (Bonus) when:
Conclusion
Quick Troubleshooting
Shoutouts & References

Why Claude Skills Don't Trigger

The issue isn’t that Claude Skills don’t work. They do. The problem is when they activate. As activation depends on Claude’s interpretation of your prompt. It decides whether a skill is relevant, and sometimes it guesses wrong. That’s why skills don’t always fire when you expect.

So, instead of leaving activation up to chance, we can guide Claude so skills trigger automatically every time.

Here's how:

Fix 1: Detection Hook + Trigger Rules

We owe this fix to Claude hooks , by the way. (ironically)

For this fix, we use the UserPromptSubmit hook, which runs every time you send a prompt to Claude, before it responds. This lets us inject instructions into every prompt Claude sees, giving us reliable control over which skills run.

Here's how it works:

You type a prompt that should trigger a skill.
The UserPromptSubmit hook runs.
The hook reads your prompt and checks it against skill-rules.json.
If there’s a match, the hook adds a small instruction telling Claude which skill to activate.
Claude sees your prompt with the hook’s instruction.
The correct skill runs automatically.

This setup lets us reliably activate skills without manually calling them.

Next, we’ll walk through an example using the valibot validation skill to show exactly how to configure the hook and trigger rules

What we Need the Skill to do

We need the skill to:

Guide Claude to use composable validators like v.pipe()
Ensure proper TypeScript type inference
Make skill activation reliable whenever validation is mentioned

Why valibot? It only loads the validators Claude actually uses, so token usage stays low and the skill runs fast. This matters when you're triggering skills throughout a coding session.

What We Need to Install

To make this work automatically, we’ll set up:

UserPromptSubmit hook – runs on every prompt you send to Claude
Configuration file – tells the hook when to suggest skills
Settings update – activates the hook

Step 1

Note: Ensure you have the valibot library installed.

Copy the valibot skill into your .skills/directory

Step 2 - Create the Hook Files

To make the UserPromptSubmit hook work for skill activation, you need two files in your .claude/hooks/ directory. Each file has a clear role:

.claude/hooks/skill-activation-prompt.sh – a shell script that runs automatically whenever you submit a prompt. Its job is to invoke the TypeScript script that handles the hook logic.
.claude/hooks/skill-activation-prompt.ts – contains the logic that reads your prompt and checks it against your skill-trigger rules defined in a JSON file. If a rule matches, it injects instructions into the prompt so Claude can activate the correct skill.

This separation keeps things modular: the shell script handles execution, the TypeScript script handles logic, and the JSON file holds the actual rules. Together, they let the hook run on every prompt and guide Claude reliably.

File 1: .claude/hooks/skill-activation-prompt.sh

#!/bin/bash
set -e

cd "$CLAUDE_PROJECT_DIR/.claude/hooks"
cat | npx tsx skill-activation-prompt.ts

Make it executable:

chmod +x .claude/hooks/skill-activation-prompt.sh

File 2: .claude/hooks/skill-activation-prompt.ts

#!/usr/bin/env node
import { readFileSync } from 'fs';
import { join } from 'path';

interface HookInput {
    session_id: string;
    transcript_path: string;
    cwd: string;
    permission_mode: string;
    prompt: string;
}

interface PromptTriggers {
    keywords?: string[];
    intentPatterns?: string[];
}

interface SkillRule {
    type: 'guardrail' | 'domain';
    enforcement: 'block' | 'suggest' | 'warn';
    priority: 'critical' | 'high' | 'medium' | 'low';
    promptTriggers?: PromptTriggers;
}

interface SkillRules {
    version: string;
    skills: Record<string, SkillRule>;
}

interface MatchedSkill {
    name: string;
    matchType: 'keyword' | 'intent';
    config: SkillRule;
}

async function main() {
    try {
        const input = readFileSync(0, 'utf-8');
        const data: HookInput = JSON.parse(input);
        const prompt = data.prompt.toLowerCase();

        const projectDir = process.env.CLAUDE_PROJECT_DIR || '$HOME/project';
        const rulesPath = join(projectDir, '.claude', 'skills', 'skill-rules.json');
        const rules: SkillRules = JSON.parse(readFileSync(rulesPath, 'utf-8'));

        const matchedSkills: MatchedSkill[] = [];

        for (const [skillName, config] of Object.entries(rules.skills)) {
            const triggers = config.promptTriggers;
            if (!triggers) {
                continue;
            }

            if (triggers.keywords) {
                const keywordMatch = triggers.keywords.some(kw =>
                    prompt.includes(kw.toLowerCase())
                );
                if (keywordMatch) {
                    matchedSkills.push({ name: skillName, matchType: 'keyword', config });
                    continue;
                }
            }

            if (triggers.intentPatterns) {
                const intentMatch = triggers.intentPatterns.some(pattern => {
                    const regex = new RegExp(pattern, 'i');
                    return regex.test(prompt);
                });
                if (intentMatch) {
                    matchedSkills.push({ name: skillName, matchType: 'intent', config });
                }
            }
        }

        if (matchedSkills.length > 0) {
            let output = '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n';
            output += '🎯 SKILL ACTIVATION CHECK\n';
            output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n';

            const critical = matchedSkills.filter(s => s.config.priority === 'critical');
            const high = matchedSkills.filter(s => s.config.priority === 'high');
            const medium = matchedSkills.filter(s => s.config.priority === 'medium');
            const low = matchedSkills.filter(s => s.config.priority === 'low');

            if (critical.length > 0) {
                output += '⚠️ CRITICAL SKILLS (REQUIRED):\n';
                critical.forEach(s => output += `  → ${s.name}\n`);
                output += '\n';
            }

            if (high.length > 0) {
                output += '📚 RECOMMENDED SKILLS:\n';
                high.forEach(s => output += `  → ${s.name}\n`);
                output += '\n';
            }

            if (medium.length > 0) {
                output += '💡 SUGGESTED SKILLS:\n';
                medium.forEach(s => output += `  → ${s.name}\n`);
                output += '\n';
            }

            if (low.length > 0) {
                output += '📌 OPTIONAL SKILLS:\n';
                low.forEach(s => output += `  → ${s.name}\n`);
                output += '\n';
            }

            output += 'ACTION: Use Skill tool BEFORE responding\n';
            output += '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n';

            console.log(output);
        }

        process.exit(0);
    } catch (err) {
        console.error('Error in skill-activation-prompt hook:', err);
        process.exit(1);
    }
}

main().catch(err => {
    console.error('Uncaught error:', err);
    process.exit(1);
});

Install dependencies:

cd .claude/hooks
npm init -y  # Creates package.json if you don't have one
npm install tsx  # Required to run TypeScript files

Step 2: Configure Skill Triggers

Create .claude/skills/skill-rules.json:

{
  "version": "1.0",
  "skills": {
    "valibot-usage": {
      "type": "domain",
      "enforcement": "suggest",
      "priority": "high",
      "description": "Valibot schema validation",
      "promptTriggers": {
        "keywords": [
          "validate",
          "validation",
          "schema",
          "type check",
          "verify input",
          "validate data",
          "parse request"
        ]
      },
      "fileTriggers": {
        "pathPatterns": [
          "**/*.ts",
          "**/*.js"
        ]
      }
    }
  }
}

This file tells the hook when to suggest the Valibot-usage skill. When you type words like "validate" or "schema" while editing TypeScript or JavaScript files, the hook detects it and suggests the Valibot-usage skill.

Each skill you want to auto-trigger needs an entry in this file. Right now we only have Valibot-usage, but you can add more skills later by adding more entries under "skills". For example, if you had a React patterns skill, you'd add another entry for "react-patterns" with its own keywords and file patterns.

Step 3: Activate the Hook

Add this to your .claude/settings.json:

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/skill-activation-prompt.sh"
          }
        ]
      }
    ]
  }
}

If you already have a settings.json with other hooks, just add the UserPromptSubmit section.

How It Works

Before:

You: "validate this user input"
Claude: *writes manual if-statement validation*

After:

You: "validate this user input"
Hook: detects "validate" + .ts file
Claude: RECOMMENDED SKILLS:
  Valibot-usage 

ACTION: Use Skill tool BEFORE responding"
You: "yes"
Claude: uses valibot-usage skill to generate schema

One important thing to know: The hook doesn't automatically load skills for you. It detects when a skill is relevant and tells Claude about it, but Claude will still ask you "Should I load the Valibot-usage skill?" before actually using it. You have to say yes.

This is by design. The hook handles the detection part automatically so you don't have to remember which skill to use, but you still get final say on whether to load it.

Now when you're building an API endpoint and ask Claude to validate the request body, it uses Valibot's composable validators, guided by thevalibot-usageskill. instead of writing manual checks. The validation logic stays readable even as your schemas get more complex.

Fix 2: Forced Skill Evaluation

This method also uses the UserPromptSubmit hook. But instead of just checking rules quietly, it forces Claude to evaluate each skill before writing any code. Claude has to commit to a skill decision instead of skipping straight to implementation.

How Forced Skill Evaluation Works

When you type a prompt like "validate this API request," Claude goes through three steps:

a. Evaluate
Lists every skill and decides YES or NO with a reason:

valibot-usage: YES - need schema validation
react-patterns: NO - not building UI

b. Activate
Calls the skill for each YES decision:

Skill(valibot-usage)

c. Implement
Writes the code after committing to the skill decisions.

This fix makes Claude stop and evaluate each skill before touching any code. It can't skip straight to implementation.

Using words like MANDATORY or CRITICAL makes it harder for Claude to skip the activation step.

How to Set it up

Create .claude/hooks/skill-forced-eval.sh:

#!/bin/bash
# UserPromptSubmit hook that forces explicit skill evaluation
#
# This hook requires Claude to explicitly evaluate each available skill
# before proceeding with implementation.
#
# Installation: Copy to .claude/hooks/UserPromptSubmit

cat <<'EOF'
INSTRUCTION: MANDATORY SKILL ACTIVATION SEQUENCE

Step 1 - EVALUATE (do this in your response):
For each skill in <available_skills>, state: [skill-name] - YES/NO - [reason]

Step 2 - ACTIVATE (do this immediately after Step 1):
IF any skills are YES → Use Skill(skill-name) tool for EACH relevant skill NOW
IF no skills are YES → State "No skills needed" and proceed

Step 3 - IMPLEMENT:
Only after Step 2 is complete, proceed with implementation.

CRITICAL: You MUST call Skill() tool in Step 2. Do NOT skip to implementation.
The evaluation (Step 1) is WORTHLESS unless you ACTIVATE (Step 2) the skills.

Example of correct sequence:
- research: NO - not a research task
- Valibot-usage: YES - need schema validation 

[Then IMMEDIATELY use Skill() tool:]
> Skill(Valibot-usage)

[THEN and ONLY THEN start implementation]
EOF

Make it executable:

chmod +x .claude/hooks/skill-forced-eval.sh

Add to .claude/settings.json:

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/skill-forced-eval.sh"
          }
        ]
      }
    ]
  }
}

Claude writes down the decision, then has to follow through. Once it says "YES - need schema validation", it's locked in. It has to activate the skill before coding.

It's more verbose though. You'll see Claude list every skill before it starts. But it works because Claude has to commit to the decision in writing before implementing anything.

Bonus: Settings Tweak Worth Testing

There's one more approach that's simpler than hooks but less consistent. If you don't want to deal with hook files, you can add instructions directly to Claude Code's settings.

Go to Settings at Custom Instructions and add this:

MANDATORY: Before responding to ANY prompt, you MUST:
1. Check ALL available skills in <available_skills>
2. Identify which skills apply to this prompt
3. Use Skill(skill-name) for EACH applicable skill
4. ONLY THEN start your response

Do NOT skip skill activation. Do NOT proceed without checking skills.
This is NON-NEGOTIABLE for every single prompt.

The aggressive language ("MANDATORY", "NON-NEGOTIABLE") makes it harder for Claude to ignore. It becomes part of Claude's system context on every interaction.

This works, but it's not as reliable as the hook approaches, as custom instructions sit in the background. Claude can still override them when it thinks it knows better, but Hooks force the behavior by injecting it into every prompt.

Which Method Should You Use?

The real question isn't which method has better pros/cons but about how you work and what you're building.

Use Detection Hook (Fix 1) when:

You're managing multiple skills across different contexts

If you have 5+ skills (validation, React patterns, database queries, API design, testing), Fix 1 scales better. The keyword-based detection in skill-rules.json lets you map different triggers to different skills without forcing Claude to evaluate everything every time.

Example: Your prompt mentions "validate user input" while editing a TypeScript API route. The hook detects validate + .ts file context and suggests only the Valibot skillâ€”not your React patterns or database skills. This selective activation keeps Claude focused.

Your skills have clear linguistic or contextual triggers

Fix 1 works best when you can define precise activation conditions. If you can articulate "when the user says X while editing Y file type, suggest Z skill," the detection hook will reliably fire.

The JSON configuration gives you fine-grained control:

Keywords: ["validate", "schema", "parse request"]
Intent patterns: Regex matching like "verify.*input" or "check.*data"
File patterns: **/*.ts, **/api/**/*.js

You want to preserve Claude's autonomy for simple tasks

The detection hook suggests skills but still asks permission. This matters when you're doing something straightforward that doesn't need skill intervention. You type "add a console.log here" ”no skill triggers, Claude just does it without an evaluation overhead.

You're willing to invest setup time for long-term efficiency

Fix 1 requires more initial work: shell script, TypeScript logic, JSON configuration, npm dependencies. But once it's set up, adding new skills is just editing one JSON file. If you're building a skill library for a team or long-term project, this upfront cost pays off.

Use Forced Evaluation (Fix 2) when:

You have 2-3 critical skills that must never be forgotten

If your project relies on a small set of non-negotiable patterns. Say a Valibot validation skill, a custom auth pattern, and a logging standard. Fix 2 guarantees Claude considers them every time. The three-step evaluation sequence (Evaluate, Activate and Implement) makes skill usage mandatory, not optional.

Your skills apply broadly but Claude keeps missing them

Some skills don't have obvious keyword triggers. A "clean code principles" skill or "error handling patterns" skill might be relevant to almost any code task, but there's no single word that captures when to use them. Fix 2 solves this by making Claude explicitly evaluate every skill regardless of the prompt content.

You're okay with verbosity for reliability

Every prompt gets the full evaluation list. If you ask Claude to "fix a typo," it still lists every skill before doing anything. This is the tradeoff. 100% reliability in exchange for seeing the evaluation process every time. If you're working on something where correctness matters more than speed, this is worth it.

Use Custom Instructions (Bonus) when:

You're testing whether skill activation is even your bottleneck

Before investing in hooks, spend 10 minutes adding the instruction to settings. If Claude starts consistently using skills, maybe the issue was just a gentle reminder, not a technical problem. If it doesn't work, you've learned that you need the stronger mechanisms.

You have one dominant skill that should almost always load

If 90% of your work involves one skill (like a specific framework pattern), custom instructions can work as a quick solution. "Always check if the React-patterns skill applies" is simpler than setting up hooks for a single skill.

Your project is temporary or exploratory

Prototyping for a few days? Building a proof-of-concept? Custom instructions give you skill activation without committing to infrastructure. You can remove it just as easily when the project ends.

Conclusion

Claude Code skills have the potential to solve a lot of the AI “slop” that happens when a model guesses or skips steps. Their real power comes when they trigger autonomously, reliably, and in the right context.

With the fixes we’ve covered, using UserPromptSubmit hook for detection and forced evaluation. You can guide Claude to activate skills consistently, without manual intervention. That means fewer mistakes, cleaner code, and more predictable results.

Skills don’t just exist to sit in the background; when set up right, they become a trusted part of your AI workflow, letting Claude handle complex tasks like validation, type inference, or any custom logic you design.

Autonomous skills aren’t just convenient, they’re the key to unlocking Claude’s full potential.

Quick Troubleshooting

tsx: command not found
Run: npm install tsx in .claude/hooks/

Hook not triggering
Check: chmod +x skill-activation-prompt.sh and restart Claude Code

skill-rules.json not found

Verify path: .claude/skills/skill-rules.json (not .claude/hooks/)

Shoutouts & References

The hook system used in fix 1 was built by diet103 (check his full code infrastructure for more).

The hook system used in fix 2 is based on research by Scott Spence.

Understanding Valibot: How it Works and When to Use it

Oluwawunmi Adesewa — Sun, 28 Sep 2025 05:25:02 +0000

If you've looked up Valibot, you've probably noticed that most write-ups just say it's "lighter and faster" but barely explain how or when to use it.

For example, someone on r/reactjs mentioned:

"The main issue right now is that it is really hard to discover Valibot features and understand how they work as the documentation is lacking at this stage. This IMO, is the biggest blocker right now."

That gap is what this article intends to fill. I’ll walk through how Valibot’s functional design works, compare it with alternatives, and show where it truly shines (and where it might need more work).

A Few Things to Keep in Mind

Before diving deeper, here are a few quick notes about Valibot that will help frame everything else.

Valibot is a functional programming-based validation library.
Its design leads to smaller bundle sizes, faster performance, and easier testing.
If you’ve used Zod, Yup, or Joi, the differences here come down to how validation is built on pure functions and composition rather than objects and method chaining.

Keep these points in mind while we break down how Valibot actually works.

Valibot Relies Heavily on Functional Programming Principles

Valibot data validation library relies heavily on functional programming principles. It is designed around composing small, independent, pure functions to build and execute validation and transformation pipelines.

This core architectural decision is what enables everything else — the smaller bundles, the better performance, the reusability patterns, and the TypeScript integration that people talk about.

What "Functional Programming Principles" Means in Valibot

Here is how Valibot incorporates the core concepts of functional programming:

1. Small, Pure Functions

Valibot's API is intentionally designed around many small, single-purpose functions. For example, instead of a large string object with many methods attached to it (as seen in libraries like Zod), Valibot provides independent functions like string(), minLength(), email(), and trim().

// Zod approach - methods on objects
const schema = z.string().email().min(5);

// Valibot approach - composed functions  
const schema = pipe(string(), email(), minLength(5));

Each function does one thing and does it well. string() validates that something is a string. email() validates email format. minLength() checks minimum length. They don't know or care about each other—they're pure functions that take an input and return a validated output (or throw an error).

2. Functional Composition and Data Pipelines

Instead of method chaining, which is more common in object-oriented approaches, Valibot uses a pipe() function to compose multiple validation actions.

import { pipe, string, minLength, email } from 'valibot';

const LoginEmailSchema = pipe(
  string(),
  minLength(1, 'Please enter your email'),
  email('The email address is badly formatted')
);

In this example, the string(), minLength(), and email() functions are passed into the pipe() function. The data being validated flows through these functions, one after the other, in a consistent, predictable sequence.

This is function composition—you're building complex behavior by combining simpler functions, rather than creating large objects with many methods.

3. Immutability

When Valibot transforms data (for example, using the trim() function), it does not mutate the original input. Instead, it returns a new value. This immutability principle ensures that:

Your original data is never accidentally modified
Functions are predictable—same input always produces same output
Side effects are minimized
Code is easier to test and debug

Why This Modular Approach Has Several Benefits

Now that we understand what Valibot's functional approach actually means, we can see why it creates tangible advantages.

Tree-shaking: The Bundle Size Revolution

Because each function is a separate module, a bundler can tree-shake your code, removing any validation functions you don't actually use. This is the main reason for Valibot's famously small bundle size.

Here’s the difference:

Zod's approach:

import { z } from 'zod';
// This might pull in string methods, number methods, object methods, etc.
// even if you only use z.string().email()

Valibot's approach:

import { pipe, string, email } from 'valibot';
// Your bundler includes exactly these three functions, nothing else

When I tested this with a real application:

Zod: 31KB (minified + gzipped)
Valibot: 8KB (minified + gzipped)

The exact savings depend on which validators you use, but Valibot consistently delivers 2-4x smaller bundles due to its tree-shakable architecture.

You can test this yourself at bundlejs.com with your specific validation needs.

That 23KB difference comes directly from the modular function design enabling better tree-shaking.

Testability: Each Isolated Function is Easy to Test Thoroughly

Each validation function can be tested in complete isolation:

// Test just the email validator
const emailValidator = email('Invalid email');
expect(() => emailValidator('test@example.com')).not.toThrow();
expect(() => emailValidator('invalid')).toThrow('Invalid email');

// Test just the minLength validator
const lengthValidator = minLength(5, 'Too short');
expect(() => lengthValidator('hello')).not.toThrow();
expect(() => lengthValidator('hi')).toThrow('Too short');

This granular testability contributes to the library's high test coverage and reliability. You can verify each piece of validation logic independently, making bugs easier to isolate and fix.

Performance: Function Calls vs Method Lookups

JavaScript engines are highly optimized for function calls. When you write pipe(string(), email()), the engine can:

Optimize the function calls more aggressively
Eliminate intermediate object creation
Reduce memory allocation overhead
Apply better caching strategies

In contrast, method chaining like z.string().email() involves:

Object method lookups
Intermediate object creation for each step in the chain
More complex memory management

This is why Valibot shows significant performance improvements in high-frequency scenarios:

Real-time validation: 40-60% faster
Batch processing: 2-3x improvement

Reusability Through Composition

The functional approach makes reusable validation patterns natural:

// Define reusable validators as composed functions
const emailValidator = pipe(string(), email());
const strongPassword = pipe(
  string(),
  minLength(8),
  regex(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)/)
);

// Compose them into different schemas
const userRegistration = object({
  email: emailValidator,
  password: strongPassword,
  confirmPassword: strongPassword
});

const adminUser = object({
  email: emailValidator, 
  password: strongPassword,
  permissions: array(string())
});

Because validators are just functions, you can:

Store them in variables
Pass them as arguments to other functions
Combine them in any way you need
Test them independently
Modify them in one place and have changes apply everywhere

This Changes How You Think About Validation

Once you understand that Valibot is built on functional programming principles, everything else makes sense.

Why the bundle is smaller: Tree-shaking works better with independent functions than with class methods.

Why it's faster: Function calls are more optimizable than method chains.

Why TypeScript integration is seamless: Pure functions with clear input/output types enable better type inference.

Why reusability feels natural: Functions compose together more easily than object methods.

Why custom validators integrate smoothly: You're just writing another function that follows the same patterns.

The functional programming foundation is what enables all the other benefits that make Valibot compelling.

When This Approach Works Best

Understanding Valibot's functional nature helps you know when to choose it.

Great fit when:

You're comfortable with functional programming patterns
Bundle size and performance matter for your use case
You need highly reusable validation logic
You're working in a TypeScript-first environment

Less ideal when:

Your team strongly prefers object-oriented patterns: If everyone is used to Zod-style chaining or class-based libraries, Valibot’s functional approach may feel unnatural and slow adoption.
You have a large existing validation layer: Migrating hundreds of Zod schemas to Valibot can be tedious. In such cases, the gains may not justify the cost unless bundle size or performance is a major pain point.
Ecosystem integrations are important: Right now, Valibot doesn’t have the same level of adoption as Zod or Yup. That means fewer ready-made adapters for form libraries (like React Hook Form), frameworks, and API tools. You may need to write your own glue code until the ecosystem matures.

The Bottom Line

Valibot isn't just "Zod but smaller." It's a fundamentally different approach to validation based on functional programming principles.

The small bundle size, better performance, excellent TypeScript integration, and reusability patterns all flow from this core architectural choice. Whether those benefits matter for your specific project is what should guide your decision to adopt it.

But now you understand why those benefits exist and what tradeoffs they involve.

Best JavaScript Backend Automation Tools (With TypeScript Support)

Oluwawunmi Adesewa — Fri, 22 Aug 2025 05:14:59 +0000

Best JavaScript Backend Automation Tools (With TypeScript Support)

I’ve noticed that while there’s a lot of content on using AI for frontend work, backend automation doesn’t get the same attention. Most of the time, tutorials focus on frameworks or architecture, but not on automating the day-to-day backend tasks we all repeat.

To fix that gap, I put this post together to highlight five JavaScript (and TypeScript) backend automation tools that can take care of the repetitive parts of backend development. Whether it’s writing data validation logic, database queries, API endpoints, type-safe client code, or SDK documentation, there’s a tool here to help you skip boilerplate and focus on shipping features.

Why Automate Backend Development in JavaScript
5 JavaScript Backend Automation Tools
- Valibot: Automating Data Validation
- Prisma: Automating Database Queries
- Convex: Backend-as-a-Service with Automation Built In
- ts-rest: Automating API Contracts and Clients
- Fern: Automating SDKs and API Documentation
Picking the Right Backend Automation Tool
FAQ: JavaScript Backend Automation

Why Automate Backend Development in JavaScript

Most backend development boils down to repetitive work like writing validation logic, database queries, and endpoint handlers for every feature.

Libraries like Zod, Joi, and Yup help with validation, while ORMs like Prisma simplify database queries. But you still end up wiring everything together yourself. Schemas drift from models, client code falls out of sync, and you’re maintaining multiple sources of truth.

Backend automation tools solve that problem.

Instead of redefining the same structures in multiple places, you define your schema once, and the tools generate everything else—validation, database operations, API endpoints, and client interfaces.

They’re also relatively easy to add to existing projects and enforce consistent patterns across your codebase. That consistency is hard to maintain by hand and becomes more valuable as your app grows.

5 JavaScript Backend Automation Tools

Each of these tools tackles a different piece of the backend puzzle. Used together, they can save you hours of wiring and boilerplate.

Valibot: Automating Data Validation

Validation is usually the first step in any backend. You need to make sure user input matches the structure your app expects. Traditionally, you’d write rules with libraries like Zod, Joi, or Yup, but that often means duplicating logic across frontend and backend.

Valibot fixes this by letting you define validation schemas once and reuse them everywhere.

In plain JavaScript, you get runtime validation.
In TypeScript, those same schemas generate static types, so errors get caught before your app even compiles.

Compared to Zod, Valibot is smaller, more modular, and built for performance-sensitive environments.

When to use Valibot

If you’re tired of duplicating validation logic across frontend and backend
If you want strong type safety in TypeScript

Valibot Docs

Prisma: Automating Database Queries

After validation comes persistence. Most database work is just CRUD (create, read, update, delete). Writing SQL or ORM queries by hand is repetitive, and keeping them in sync with schema changes is error-prone.

Prisma changes that. You define your data models in a Prisma schema, and Prisma generates a fully typed client for queries.

In JavaScript, you get a structured, intuitive client API.
In TypeScript, you also get autocomplete and compile-time checks.

The result? Queries that always match your schema, and fewer runtime surprises like missing fields or incorrect column names.

When to use Prisma

If you want to avoid repetitive SQL
If you want type-safe queries with autocomplete

Prisma Docs

Convex: Backend-as-a-Service with Automation Built In

Validation and queries solve part of the backend problem, but you still have to manage infrastructure: servers, deployments, syncing logic between backend and frontend.

Convex takes a different approach. It’s a backend-as-a-service where you define data models and functions in JS/TS, and Convex takes care of the rest:

Storage
Hosting
Generating a type-safe client for the frontend

It’s especially useful for real-time apps that need reactive data subscriptions. You don’t have to think about servers or deployment pipelines—just write your functions and ship.

When to use Convex

If you don’t want to manage servers or infrastructure
If you need a backend tightly integrated with JS/TS

Convex Docs

ts-rest: Automating API Contracts and Clients

Even with validation, queries, and hosting sorted, there’s a common pain point: keeping APIs in sync. Backends define routes and responses, frontends implement clients, and small mismatches cause big bugs.

ts-rest prevents this. You define your API contract once, and it generates both backend routes and a type-safe client.

In JavaScript, you get a consistent client API.
In TypeScript, you also get compile-time guarantees.

This means the frontend and backend always speak the same language—no manual syncing required.

When to use ts-rest

If your frontend and backend live in separate codebases
If you want to eliminate mismatches between client and server

ts-rest Docs

Fern: Automating SDKs and API Documentation

If you’re exposing an API to other developers, you’ll need SDKs and documentation. Writing both by hand is slow, and they often get out of date.

Fern automates this. From a single API definition (like an OpenAPI spec), it generates:

Client SDKs in multiple languages
Always-up-to-date API documentation

This makes your API easier for other developers to use while keeping your SDKs and docs in sync automatically.

When to use Fern

If you’re building public APIs
If you need SDKs and docs that don’t fall behind your API

Fern Docs

Picking the Right Backend Automation Tool

If backend development feels repetitive, it’s because much of it is. These tools reduce duplication, enforce consistency, and help you focus on building features instead of boilerplate.

Start with Valibot if you’re duplicating validation logic.
Use Prisma for type-safe database queries.
Try Convex if you want a managed backend that just works.
Reach for ts-rest to keep frontend and backend in sync.
Pick Fern if you’re exposing APIs to other developers.

You can also mix and match. For example:

Valibot for validation + Prisma for database + ts-rest for API contracts = a clean, automated Node.js backend.

FAQ: JavaScript Backend Automation

What is backend automation?

Backend automation uses tools to generate repetitive backend code—validation, queries, endpoints, docs—from a single definition.

Is backend automation only for TypeScript?

No. All of these tools work in JavaScript, but TypeScript users get extra type safety benefits.

Can I use multiple tools together?

Yes. Many teams combine them: Valibot for validation, Prisma for queries, ts-rest for API contracts, etc.

Conclusion

With these tools, you can skip boilerplate and spend more time on features.

Backend automation isn’t about replacing your workflow—it’s about removing the boring parts so you can ship faster, with fewer bugs, and with code that scales.

How to Use ChatGPT for Coding: Prompts and Examples for Python, JavaScript, and More

Oluwawunmi Adesewa — Thu, 26 Jun 2025 05:02:20 +0000

AI is changing how developers write code, solve bugs, and ship features. Tools like ChatGPT are no longer just nice to have, they're becoming part of the daily workflow.

But using ChatGPT for coding effectively takes more than just asking, “Can you write this for me?” You need to understand what it’s good at, what it struggles with, and how to prompt it properly.

This guide is built for developers who want to use ChatGPT as a practical coding assistant, not as a replacement for real understanding, but as a tool to move faster, reduce boilerplate, and learn on the job.

What Can ChatGPT Do for Developers?
- 1. Generate Code Snippets
- 2. Debug and Fix Errors
- 3. Explain Code in Plain English
- 4. Translate Between Programming Languages
- 5. Generate Tests
Best Prompt Practices for Developers
Real-World Use Cases by Language
- Python
- JavaScript / React
- SQL
- Bash
Debugging Code with ChatGPT
ChatGPT vs Copilot: Which Should You Use?
Limitations and Warnings
Frequently Asked Questions
Final Thoughts: ChatGPT Won’t Code for You But It Can Make You Faster

What Can ChatGPT Do for Developers?

Let’s start with what ChatGPT can help you with. These are the most common tasks developers use it for:

1. Generate Code Snippets

You can describe a small task in plain English and get working code in return.

Example:

Write a Python function that validates an email address using regex.

ChatGPT will generate the function, and you can quickly test or modify it as needed. This saves time writing from scratch.

2. Debug and Fix Errors

Paste in your error message or broken code, and ask what’s wrong. ChatGPT will often point you toward the fix, especially for common issues.

Example:

I’m getting a TypeError when mapping over an array in JavaScript. Here’s my code. What’s wrong?

3. Explain Code in Plain English

Use ChatGPT to understand legacy code, new APIs, or libraries you're not familiar with.

Example:

Explain this function line by line.

What does this SQL query do?

It’s especially helpful when learning a new language or reading poorly documented code.

4. Translate Between Programming Languages

You can convert a function or snippet from one language to another.

Example:

Convert this Python function to JavaScript.

Translate this SQL query into MongoDB syntax.

Great when you're working across multiple stacks or switching environments.

5. Generate Tests

You can ask ChatGPT to write unit tests for a given function.

Example:

Write a Jest test for this React component.

Create unit tests for this Go function.

It usually follows standard testing patterns, saving setup time.

Best Prompt Practices for Developers

You won’t get good code if you give a vague prompt. The more detail and context you provide, the more helpful ChatGPT becomes.

Always Include:

The goal (what you want to build or fix)
The environment (language, framework, context)
The existing code (if applicable)
The error message (if debugging)

Bad Prompt:

Write a form.

Better Prompt:

Write a login form in React that uses Tailwind CSS. It should have email and password fields and show an error if the input is empty.

Advanced Tip:

Break complex prompts into smaller steps: First ask for the structure, then styling, then validation.

Avoid Pasting Proprietary Code: Be careful not to include sensitive data, internal logic, or anything that could expose business IP. ChatGPT sessions are private, but it’s still best practice to redact or abstract details.

For more advanced prompt strategies that maintain privacy and improve accuracy, see this guide on advanced prompting techniques

Real-World Use Cases by Language

Let’s look at how developers use ChatGPT in different programming languages:

Python

Data processing: Ask it to clean, format, or filter data with pandas.
Scripting: Generate one-off utilities or CLI tools.
Automation: Write scripts to rename files, organize folders, or process logs.

Example prompt:

Write a Python script that reads a CSV file and removes duplicate rows.

JavaScript / React

Component generation: Build reusable components like buttons, forms, modals.
DOM scripting: Ask for vanilla JS solutions to small UI tasks.
Refactoring: Simplify complex logic into cleaner functions.

Example prompt:

Build a responsive navbar in React with a mobile dropdown. Use Tailwind CSS.

SQL

Query generation: Ask for specific queries by describing your data structure.
Performance help: Paste a slow query and ask how to optimize it.
Schema design: Generate normalized tables or suggest indexes.

Example prompt:

Write a SQL query to find the top 10 customers by total purchase amount in the last 30 days.

Bash

Quick scripts: Automate daily tasks like backups or log rotation.
Cron job creation: Ask for scheduling examples and common patterns.

Example prompt:

Write a bash script that zips all .log files in a folder and deletes them after.

Debugging Code with ChatGPT

Here’s a common use case: You paste in an error, and it helps you fix it.

Example:

You say:

I’m getting TypeError: undefined is not a function in my React app.

You include your code, and ChatGPT walks you through the issue:

It identifies where you're calling a function that might be undefined.
It suggests adding a null check or verifying the import.

It’s not perfect, but it’s often enough to unblock you quickly.

You can also ask:

What does this error mean?
How do I fix this stack trace?
Why is this promise not resolving?

It works best when the error is isolated and reproducible.

ChatGPT vs Copilot: Which Should You Use?

Both tools help with coding, but they serve different purposes.

Feature	ChatGPT	GitHub Copilot
Interface	Chat-based	Inline in code editor
Best For	Explanation and code reasoning	Fast code suggestions
Ideal Use	Debugging, learning, prototyping	Writing small snippets
Language Support	Broad (English + code)	Strong for JavaScript, Python

Use ChatGPT when:

You want a deeper explanation
You’re planning a larger feature
You want help debugging

Use Copilot when:

You’re moving fast and just need quick code
You want autocomplete inside your IDE

Many developers use both.

Limitations and Warnings

ChatGPT can speed things up, but it’s not always reliable. Here's what to watch out for:

Don’t blindly trust the code

ChatGPT can generate:

Insecure code (e.g., SQL injection vulnerabilities)
Inefficient algorithms
Code that doesn’t run

Always test AI-generated code.

It has no live context

ChatGPT doesn’t know your project structure unless you show it. It won’t "know" your dependencies or runtime environment.

It doesn’t replace real experience

AI is useful, but it won’t make judgment calls or design scalable architectures.

Frequently Asked Questions

Is ChatGPT good for coding interviews?

Yes, it can explain algorithms, generate LeetCode-style problems, and help you understand solutions. But don’t rely on it during live interviews.

Can I use ChatGPT in a professional setting?

Yes, many developers do. Just avoid pasting sensitive or proprietary code.

Does ChatGPT learn from my code?

No. ChatGPT doesn’t remember your prompts or store your data between sessions unless you opt into custom training features.

Final Thoughts: ChatGPT Won’t Code for You But It Can Make You Faster

ChatGPT is a powerful assistant. It won’t replace good judgment, problem-solving skills, or testing—but it can help you:

Move faster on routine tasks
Get unstuck more quickly
Learn by example

If you treat it like a smart, slightly unreliable pair programmer, you’ll get the most out of it.

If this helped, I’ve got more like it. Tools, tips, and honest takes on dev workflow. Follow here or on X to catch the next one.

5 ChatGPT Prompting Techniques to Boost Developer Productivity

Oluwawunmi Adesewa — Sat, 21 Jun 2025 13:35:36 +0000

Most developers use ChatGPT for quick coding help like fixing bugs, writing functions, or understanding errors. But just using it doesn’t mean you’ve mastered it. Like any powerful tool, its real value comes from how well you use it, not just how often.

Used well, ChatGPT can be a serious productivity boost. It can help you debug faster, analyze complex codebases, scaffold APIs, automate workflows, and stay in flow during long coding sessions.

In this post, I'll break down 5 advanced ChatGPT prompting techniques for developers, each built for real-world use. Whether you’re trying to ship faster, write cleaner code, or streamline your workflow, these prompts will help you get more value out of every session.

1. Rolling Context Summaries
2. Prompt Structuring for Cleaner, Faster Output
3. Maximizing API Credits Without Losing Output Quality
4. Customizing ChatGPT to Match Your Workflow
Conclusion: Tools Only Help with Structure and Scale

1. Rolling Context Summaries

One of the biggest limits when using ChatGPT for real development is its context window. ChatGPT can only “remember” about 128,000 tokens (roughly 80,000 words) in a conversation. When your code, logs, and conversation history get longer than that, it starts dropping the earliest parts — effectively forgetting what you told it at the start.

This causes problems in long debugging sessions or complex multi-file analysis where you need consistent understanding across many messages.

The best way to handle this is with rolling context summaries. After working through a chunk of code or conversation, say every 20–30 messages, ask ChatGPT to summarize the key points so far in a few bullet points.

For example:

“Summarize our last 20 messages in 5 bullet points focusing on the main issues and solutions.”

Save that summary outside ChatGPT. When you start a new session or hit the token limit, paste the summary back into the prompt before continuing:

“Here’s what we covered before: [paste summary]. Now let’s continue debugging the payment module.”

If your sessions get very long, break them into smaller chunks and summarize each. This method keeps ChatGPT informed without repeating everything and prevents loss of context.

Without rolling summaries, ChatGPT forgets critical details, forcing you to repeat or re-explain context. Using summaries keeps workflows smooth and productive, especially for multi-file code reviews, long debugging sessions, or iterative problem solving.

2. Prompt Structuring for Cleaner, Faster Output

Even with good context management, poor prompts can still derail a session. Most code generation issues don’t come from the model being incapable, they come from instructions that are too vague or too open-ended. Left to guess, the model often produces overly verbose, unstructured, or incomplete results.

The best way to avoid this is by using simple, repeatable prompt patterns that keep the model focused on what you want and only what you want.

When working with code, a good baseline is:

"Respond with code only in CODE SNIPPET format, no explanations."

This keeps responses clean and accurate. You don’t need paragraph-long explanations in the middle of a coding session, just working code you can drop in and test. Removing unnecessary output also makes it easier to see whether the result actually changed.

When iterating on an existing file or component, these two are especially useful:

"Just provide the parts that need to be modified."

"Provide entire updated component."

The first is ideal for small tweaks. It avoids confusion from unchanged code being repeated. The second is better when changes affect multiple areas or when you want a fresh, consistent copy of the full component.

Over time, using these phrases becomes second nature. You can even save them as text snippets or shortcut keys in your setup (for example, using a browser extension or editor plugin) to save time during repeated prompting.

Without prompt structuring, LLMs tend to guess. That guesswork leads to bloated responses, wrong assumptions, or missed details. With structured prompts, responses are consistent and focused, helping you stay in flow, especially when working on large projects or switching between tasks frequently.

3. Maximizing API Credits Without Losing Output Quality

When working with the ChatGPT API — especially in iterative development workflows, it’s easy to burn through tokens without realizing it. Every message costs credits, and long prompts or verbose replies can quickly accumulate. But with a few simple habits, you can keep costs low while still getting high-quality output.

The most effective strategy is to optimize both the prompt and the model selection. Start with concise, tightly scoped instructions:

“Explain Python classes with one short example.”

“Fix the code, explain the issue, and suggest optimizations.”

“Answer in under 100 words.”

These kinds of constraints help control both input and output token counts. They also make it easier to test and read results. If you’re using the API directly, set max_tokens to explicitly cap responses — useful for automating safeguards on repeated queries.

For simpler tasks like debugging, drafting snippets, or summarizing logs, switch to lighter models like gpt-3.5-turbo or gpt-4o-mini. Reserve GPT-4 for final-stage refinement, complex reasoning, or critical correctness. This is the same strategy developers on Reddit use to stretch credit limits — do 80% of the work with cheaper models, and only escalate when needed.

To avoid redundant calls, cache common responses. If you’ve already asked the model to explain a type error or a specific regex function, save that answer locally or in a shared store. When the same issue comes up again, just reuse the result. This is especially useful if you’re building tools that field similar prompts repeatedly.

You can also batch related queries. Instead of three back-and-forths (“Fix this,” then “Explain it,” then “Suggest improvements”), just ask:

“Fix this code, explain what was wrong, and suggest how to make it cleaner.”

If follow-ups are likely, include them proactively:

“If you find a bug, fix it. If the logic is unclear, simplify it.”

This compresses multiple interactions into a single, efficient exchange.

To monitor usage, set a monthly budget cap in OpenAI’s dashboard. For deeper control, use libraries like tiktoken to estimate message cost before sending, or implement per-user rate limits if you’re building against the API. These tools help you stay ahead of overages, especially when usage spikes unexpectedly during testing or scaling.

Finally, when refining prompts over and over, reduce wasted iterations by:

Drafting prompts locally before calling the API
Reusing the messages array to preserve prior context without resending full logs
Embedding potential tweaks in the initial request (“If it fails, suggest alternatives.”)

Small optimizations like these add up quickly, especially in high-volume use. With structured prompting, smart model selection, and a few guardrails, it’s possible to run large, useful sessions while staying well under credit limits.

4. Customizing ChatGPT to Match Your Workflow

Once you’ve optimized your context, prompting, and credit usage, the next step is tailoring ChatGPT to your specific use case. Out of the box, the model is general-purpose, but with a few small changes, you can make it behave more like a teammate that understands your coding style, preferences, and domain.

The most effective way to do this is through custom instructions. These let you define how ChatGPT should behave and what kind of responses you want. For example:

“You are a concise Python developer who always includes type hints.”

“When asked to refactor code, always explain changes in a bullet list.”

“Keep responses under 150 words unless otherwise requested.”

You can set this once and have it apply to every session, saving time and reducing the need for repetitive prompt engineering. In API calls, this works by prepending a system message (e.g., {"role": "system", "content": "You are..."}), while in the ChatGPT UI, it lives under custom settings.

For even more control, use function calling or tools integration. This allows ChatGPT to return structured outputs (like JSON) or interact with your codebase, APIs, or tools. You can use this to:

Automate workflows (e.g., trigger actions after a valid response)
Extract structured data for parsing
Return only the function signature or schema, not the implementation

In dev-focused environments, this reduces the need for cleanup and lets you treat model output like an extension of your code editor.

If you’re using ChatGPT for team or product work, you can also create custom GPTs. These let you define tools, upload files, set behavior, and even brand the experience. Think of it as building a domain-specific assistant that’s tuned to your stack, tone, and expectations.

Finally, you can teach the model about your style through priming examples. These are simple examples of input/output pairs that show what kind of response you want. For example:

“When I say: ‘clean this up’, here’s what I expect...”

“When I give you code like this, reformat it like this.”

Providing one or two examples early in a session can guide the model for the rest of the conversation, especially helpful for maintaining consistency across multiple outputs.

Customizing ChatGPT is about automation and delegation. Whether through system messages, API-level behaviors, or primed examples, the goal is to shape the assistant so you spend less time explaining and more time building.

Conclusion: Tools Only Help with Structure and Scale

At the end of the day, tools like ChatGPT don’t think for you. They extend your reach. They help with structure, by organizing and accelerating the tasks you already understand, and with scale, by letting you iterate faster, respond quicker, and offload the repetitive parts of coding or writing.

But they can’t replace clarity of thought, sound judgment, or domain knowledge. You still have to guide the tool with tight prompts, sharp context, and a clear objective. The better your inputs, the more useful your outputs.

Used well, ChatGPT becomes less of a chatbot and more of a collaborative assistant. Something that helps you stay focused, move faster, and work at a higher level, without burning time or budget.

The more intentional your workflow, the more value you’ll get out of every session.

Looking for free AI tools to try these prompts with? Check out my hands-on review of Best Free ChatGPT Alternatives for Coding in 2025. Tested on real coding tasks with no subscriptions required.

And If this helped, I’ve got more like it. Tools, tips, and honest takes on dev workflow. Follow here or on X to catch the next one.

Best Free ChatGPT Alternatives for Coding in 2025: Tested and Compared

Oluwawunmi Adesewa — Wed, 18 Jun 2025 02:36:52 +0000

If you're working on personal projects or between jobs, you're probably looking for ways to stay productive without adding another monthly subscription. ChatGPT Plus can be helpful, but at $20/month, it’s not always easy to justify—especially if you're only using it for occasional coding tasks.

Many developers in this situation turn to free ChatGPT alternatives to help with code generation, refactoring, debugging, and documentation. The challenge is finding tools that are actually useful for software development—not just general-purpose chatbots.

In this guide, I’ve tested and compared the top free ChatGPT alternatives using real-world programming tasks. Whether you're building a portfolio project, contributing to open source, or learning new skills, these tools can help without the subscription.

What Makes a Good ChatGPT Alternative for Coding?
How I Tested These Tools
Top Recommended Free ChatGPT Alternatives for Coding
- Claude (by Anthropic)
- Bing Copilot (GPT‑4 for Free via Microsoft Edge)
- Phind (AI Search Built for Developers)
- Windsurf (Code Autocomplete and AI Assistant)
- HuggingChat (Open-Source AI You Can Run Locally)
Summary Table: How These Tools Stack Up
Conclusion

What Makes a Good ChatGPT Alternative for Coding?

Not every AI tool is built for developers. If you're looking for a useful ChatGPT alternative for coding, it needs to go beyond answering general questions. Developers need tools that understand code, support real workflows, and return trustworthy, working output.

Deep code understanding for real-world tasks

A strong ChatGPT alternative should go beyond syntax and autocomplete. It needs to understand logic, structure, and intent so it can help with debugging, code reviews, documentation, and writing tests that actually reflect what the code does.

Works inside your coding workflow

Context switching kills productivity. The right tool should integrate with your IDE, support command-line usage, or at least offer a fast and minimal interface in the browser.

Designed for software development tasks

General-purpose chatbots often break down when handling technical prompts. A good ChatGPT alternative for developers should support CLI commands, version control tasks, testing frameworks, and framework-specific help without losing context.

Produces accurate and reliable code output

Accuracy is non-negotiable. A ChatGPT alternative for coding must return valid, working code and ideally link to docs, examples, or trusted sources like GitHub.

Fast, responsive, and always available

Waiting on output slows down your train of thought. A good coding assistant should respond quickly, even during peak hours or with complex prompts.

Clear data policies and privacy protection

Most developers can’t paste sensitive or client code into a random chatbot. A good ChatGPT alternative for developers should offer transparency about data usage—or better, run locally or on-device to eliminate the risk altogether.

Want to get better results with these AI tools? Before we dive into testing, check out my guide on 5 ChatGPT Prompting Techniques That Boost Developer Productivity

How I Tested These Tools

To keep things fair, I used the same workflow across all tools. Each tool was tested with prompts designed to reflect how developers actually use AI during real coding work.

These included:

Explaining code with context: “What’s the logic of this Python function if it’s used inside a larger API handler?”
Refactoring with constraints: “Refactor this function to improve readability, but keep the same runtime complexity.”
Debugging with reasoning: “Why is this function returning None instead of a value?”
Writing test cases with coverage in mind: “Write unit tests that cover both success and failure states.”
Documenting code for a teammate: “Add docstrings that explain usage, inputs, and edge cases.”

These are pulled from real-world tasks I or teammates do regularly.

Languages used: JavaScript and Python, pulled from actual codebases.

Testing environment: Each tool was used either in the browser or via a VS Code extension (if available). I didn’t use APIs, paid upgrades, or external plugins, just the default experience developers would get when trying the tool for free.

Criteria used for evaluation:

Prompt understanding and response clarity
Accuracy of code output
Speed of response
Ability to follow up on questions
Documentation and reasoning quality
Data privacy or usage limits

This gave a clear baseline for comparison and helped surface which tools are usable for day-to-day coding—and which ones aren’t.

Based on those criteria, here are the top ChatGPT alternatives for coding, tested and compared so you can see exactly which ones are worth your time.

Top Recommended Free ChatGPT Alternatives for Coding

Claude (by Anthropic)

If you're using ChatGPT to explain code, review logic, or write clean, readable functions, Claude actually does a better job.

Claude is great at structured thinking. You can paste in a full function or even a small file, and it won’t lose the thread. It explains things clearly, asks follow-up questions when needed, and tends to write safer code by default.

The free version, Claude 3 Sonnet on claude.ai, is surprisingly powerful. You get access to Claude’s top-tier reasoning for free, and it can handle large inputs (up to 200K tokens), which is helpful if you’re pasting in big chunks of code.

It’s web-only though. So you’ll be switching tabs, but it’s fast, and you can keep a thread going as you work on a project.

Free plan includes:

Access to Claude 3 Sonnet (great at logic + explanations)
Huge context window (paste full files)
Fast response times in browser

Where it beats ChatGPT:

Better at explaining logic-heavy code, reviewing full files, and keeping context over long conversations.

Where it doesn’t:

No code interpreter, no IDE plugin, and it sometimes refuses tasks that seem risky.

Best for:

Debugging, reviewing, or walking through code with a thoughtful assistant.

Bing Copilot (GPT‑4 for Free via Microsoft Edge)

If you just want GPT‑4 for free, this is the easiest win. Bing Copilot runs on GPT‑4, includes web access, and costs nothing if you’re using Microsoft Edge. Just sign into your Microsoft account and open the Copilot sidebar or go to copilot.microsoft.com.

You get fast, high-quality code output. It also cites sources, which is handy when you want documentation links or updated examples.

Free plan includes:

Full access to GPT‑4 (with some rate limits)
Fast replies in a side panel or full window
Web access + citations
No IDE support, but easy to toggle while coding

Where it beats ChatGPT:

Same GPT‑4 model, but free. It also pulls in real-time info from the web.

Where it doesn’t:

You have to use Microsoft Edge. No file uploads or custom GPTs.

Best for:

Quick code help and debugging—anything you'd normally ask GPT‑4.

Phind (AI Search Built for Developers)

If ChatGPT and Stack Overflow had a child, it’d be Phind. Phind is built specifically for coding, with a search-style interface and built-in web access. It pulls context from docs, GitHub issues, blog posts, and more. You can ask it for code, explanations, or help fixing errors.

Free plan includes:

Unlimited questions (with some throttling)
Access to models like GPT‑4-turbo
Fast search with web results
Chat-style interface with memory

Where it beats ChatGPT:

Phind understands developer intent better than most tools and gives source-backed answers.

Where it doesn’t:

No IDE support. Struggles with multi-file logic.

Best for:

Solving coding errors, getting examples, or replacing ChatGPT + Google.

Windsurf (Code Autocomplete and AI Assistant)

Windsurf (formerly Codeium) is a strong ChatGPT alternative for fast autocomplete, in-editor chat, and smart code help—without the cost.

It integrates into your IDE, supports 70+ languages, and includes inline suggestions plus a sidebar-style AI chat. It’s privacy-friendly too, with no code used to train models.

Free plan includes:

Unlimited autocomplete and refactor features
Extensions for VS Code, JetBrains, Jupyter, and more
Works with your local files
No usage limits or paywall

Where it beats ChatGPT:

Windsurf feels like Copilot, but free. Offers real-time support inside your IDE.

Where it doesn’t:

Not ideal for long discussions or architectural help.

Best for:

Autocomplete, documentation, and fast dev support in your editor.

HuggingChat (Open-Source AI You Can Run Locally)

HuggingChat is the most developer-controlled alternative here. It’s powered by open models like LLaMA, Mistral, or Zephyr, hosted by Hugging Face. Use it in the browser or run locally with Ollama or LM Studio.

Free plan includes:

100% free via HuggingChat UI (no login needed)
Local hosting with no rate limits
Multiple model options
No data sharing if self-hosted

Where it beats ChatGPT:

Best option for devs who care about privacy or offline access.

Where it doesn’t:

Not polished. Slower answers, no IDE plugin, and less fine-tuning.

Best for:

Devs who want full control or offline AI. Not ideal for beginners.

Summary Table: How These Tools Stack Up

Tool	IDE Integration	Code Understanding	Accuracy & Docs	Speed	Privacy
Claude	❌	✅ Strong logic	✅ Structured	⚡ Fast	⚠️ Cloud-based
Bing Copilot	❌	✅ GPT‑4 accuracy	✅ Web citations	⚡ Fast	⚠️ Cloud-based
Phind	❌	✅ Context-aware	✅ Web sources	⚡ Fast	⚠️ Cloud-based
Windsurf	✅ Built-in	✅ Good	⚠️ Limited docs	⚡ Fast	✅ Strong
HuggingChat	⚠️ Local setup	✅ Basic logic	❌ Minimal docs	🐢 Varies	✅ Self-hosted

Conclusion

If you're looking for a free ChatGPT alternative for coding in 2025, you don’t need to settle for generic chatbots or limited trials.

Try a few: Claude is great for understanding code, Windsurf brings AI straight into your IDE, Phind offers search plus citations, Bing Copilot gives you GPT‑4 for free while HuggingChat gives you full control.

Use the one that fits your current work, and don’t pay unless you absolutely need to.

If this helped, I’ve got more like it. Tools, tips, and honest takes on dev workflow. Follow here or on X to catch the next one.

This Crash Tool Made Me Rethink How I Debug Mobile Apps 😲

Oluwawunmi Adesewa — Wed, 04 Jun 2025 10:39:28 +0000

The way I see it, only developers really get developers, at least when it comes to building tools other devs actually want to use.

Let me explain.

I came across Instalog.dev on LinkedIn back in April 2025. The developer behind it was announcing its launch, claiming it was a better Crashlytics alternative.

That was enough to make me try it.(Part curiosity, part spite). I have a bit of a reflex to side-eye any tool trying to ride the coattails of something established.

But… the features actually made sense.

Why Instalog Stands Out as a Crash Reporting Tool
AI-Powered Crash Summaries That Read Like a Developer
How Instalog Compares to Sentry’s AI Features
Developer-Friendly Pricing With No Event Limits
Setup Took Me 5 Minutes
Linking User Feedback Directly to Crash Reports
Why Instalog Works Better for Mobile Debugging
Final Thoughts on Instalog for Mobile Crash Reporting

Why Instalog Stands Out as a Crash Reporting Tool

Most crash reporting tools give you logs. Some add breadcrumbs. A few use AI.

Instalog does something different: it actually helps you fix the bug.

That claim sounds bold, but it’s backed by how the tool is built. Let me break down what made me say that — and what features made me stick with it.

AI-Powered Crash Summaries That Read Like a Developer

Instalog’s crash summaries don’t read like generic GPT guesses. They sound like another developer looked at your logs and said:

This API call is missing a null check. That’s what’s crashing on Android 13.

They’re specific, accurate, and fast.

You spend less time digging through logs—and more time shipping fixes. That’s the point.

How Instalog Compares to Sentry’s AI Features

I’ve seen the AI summary feature Sentry is working on. It's incredible, but it's not generally available yet. Right now, it's limited to early adopters and higher-tier plans.

Instalog’s summaries, on the other hand, are already available. They feel purpose-built for mobile, not just tacked on.

Developer-Friendly Pricing With No Event Limits

Sentry’s free plan caps out at 5,000 error events a month. After that, you’re upgrading—whether you want to or not.

Instalog’s free tier doesn’t have that kind of ceiling. It’s $0/month, no time limit, and no hard stop when things get busy.

The whole thing feels designed for solo devs and small teams. I haven’t hit any walls yet—and I’d probably know if I did.

And if you do need more, the paid plan starts at $19/month. That gets you up to 100,000 error events per month.

For comparison, Sentry’s $26/month tier only gives you 50,000 events. So you’re paying less and getting more.

Setup Took Me 5 Minutes

I tested it in a Flutter app. The process was refreshingly simple:

1.Add the package
2.Drop in your API key

Done.

It supports Flutter, iOS, Android, and React Native.

The docs lean a bit too hard on dev jokes, but they’re complete and technically solid.

Linking User Feedback Directly to Crash Reports

This one surprised me.

Users can report a bug inside the app. Instalog then ties that feedback directly to:

Logs
Stack traces
Session context
Instalog feedback

No guesswork. You get the technical and human side of the issue in one place.

This kind of context is hard to get with Crashlytics or Sentry—unless you bolt on three other tools.

Why Instalog Works Better for Mobile Debugging

The biggest difference though, is focus. Sentry is built for everything — frontend, backend, DevOps, mobile. That’s great for large teams, but it adds complexity.

Instalog is mobile-first. Not just also supports mobile — but built for mobile.

That makes it:

Faster to set up
Easier to navigate
Better tuned for how mobile debugging actually works

Final Thoughts on Instalog for Mobile Crash Reporting

Most crash reporting tools stop at visibility. More logs, more alerts, more dashboards.

Instalog goes one step further. It’s opinionated about what’s useful.

It doesn’t just show you the problem—it suggests the fix.

And while it’s still early in its development, it already solves the hardest parts of mobile crash reporting:

Real context
Developer-level insight
Simple setup

Instalog isn’t perfect, but it’s solving the right problems first. If this is its baseline, I’m genuinely curious what’s coming next.

Maybe that’s a deeper AI debugging that catches regressions before they ship.
Or just… more of this level of thoughtfulness, applied to the rest of the mobile dev stack.

Whatever it is, I'm watching.

If this helped, I’ve got more like it. Tools, tips, and honest takes on dev workflow. Follow here or on X to catch the next one.

Is Redux Necessary or is it Just About Following 'Best Practices' Without Questioning?

Oluwawunmi Adesewa — Sat, 15 Mar 2025 02:32:05 +0000

If you've been around React devs long enough, you've probably heard these sacred commandments:

Thou shalt not use Context for state management.

Thou shalt install Redux for all global state needs.

Okay, maybe they aren't official, but it sure feels that way.

But here’s the thing, Redux was built to solve a problem React no longer has at the same scale. So, do you actually need it? Or is it just about following 'best practices' without questioning?

Let's talk about it.

About Context API

Context has always been the underdog. It was originally built to solve prop drilling, not global state management. And if you tried using it for state updates back in the pre-Hooks era, you probably had flashbacks of:

<MyContext.Provider value={{ state, updateState }}>
  <SomeComponent />
</MyContext.Provider>

You just triggered a full app re-render, lol!

No wonder people ran to Redux.

But then came Hooks.

Suddenly, with useContextand useReducer, Context could actually manage state, update it predictably, and optimize performance with useMemo and React.memo.

So, does that mean Context + Hooks can replace Redux?

When Context + Hooks Is Enough

For most apps, Context + Hooks gets the job done. It works great for:

Themes (light/dark mode)
Authentication (user session data)
App settings (language, preferences)

And with useReducer, it can even handle more structured updates.

For example, let’s say you need authentication state:

const AuthContext = createContext();

const authReducer = (state, action) => {
  switch (action.type) {
    case "LOGIN":
      return { ...state, user: action.payload, isAuthenticated: true };
    case "LOGOUT":
      return { ...state, user: null, isAuthenticated: false };
    default:
      return state;
  }
};

export const AuthProvider = ({ children }) => {
  const [state, dispatch] = useReducer(authReducer, { user: null, isAuthenticated: false });

  return <AuthContext.Provider value={{ state, dispatch }}>{children}</AuthContext.Provider>;
};

export const useAuth = () => useContext(AuthContext);

That’s state management without Redux’s boilerplate.

But What About Redux’s Superpowers ?

Look, I get it, Redux does have some cool tricks:

Time-travel debugging (because who doesn’t want to play god with their app’s history?)
Middleware(like redux-thunk for async operations)
Global predictability (because structuring state matters in big teams)

But here’s the question, Does your app need all of that?

If your app is handling:

High-frequency state updates (real-time dashboards, websockets)
Complex derived state (data that depends on multiple sources)
Massive developer teams with strict state management rules

Then Redux might be worth it.

But if your app doesn’t check those boxes, you might just be over-engineering things.

Still Not Sure? Let’s Play "Should I Use Redux?"

Do you need to debug state like it’s a Netflix time-travel show?
Yes? Go Redux.
No? Context + Hooks is fine.
Does your app need middleware like redux-thunk or redux-saga?
Yes? Redux.
No? Context + Hooks.

Do you want to write a reducer, action, dispatch, and store just to toggle a sidebar?
Yes? Seek help.
No? Context + Hooks.

Small to medium apps? Context + Hooks" is your friend.
Huge, complex apps with heavy async workflows? Redux might be worth the extra setup.

Still confused? Start with Context. If things get messy, migrate to Redux later.
So,do you really need Redux?

Before you type npm install redux, ask yourself:

"Am I solving a real problem, or am I just doing what everyone else does?"

Still unsure? Check out my explanatory article about the specific use cases of each.

Happy coding !

[Boost]

Oluwawunmi Adesewa — Sat, 15 Mar 2025 01:04:07 +0000

Write Simpler Logical Expressions In Your Code with These 2 Rules!

Oluwawunmi Adesewa — Mon, 03 Mar 2025 06:16:11 +0000

When writing code, it's easy to get stuck in complex if statements and nested conditions, where a single misplaced not or and can result in bugs and errors.

But what if you could simplify logical statements and make your code more maintainable? This article shares two key rules in mathematical logic that simplify the process of writing clearer and simpler logical statements in programming.

Introduction

Consider a scenario where you need to negate a logical statement with multiple AND or OR operators.

(A and B) or (C and D)

Manually negating this expression can be tricky because logical operators have precedence rules, and distributing them incorrectly can cause a bug in your code.

De Morgan's law simplifies this process by transforming expressions like these into more manageable forms, making it easier to write and understand complex logical statements

What Is De Morgan’s Law?
De Morgan’s Laws are two transformational rules in mathematical logic that allow you to switch between AND and OR when negating an expression.

Here's how it works

NOT (A AND B) = (NOT A) OR (NOT B)
NOT (A OR B) = (NOT A) AND (NOT B)

Note: The notation for these two rules may vary slightly depending on the programming language or context, but the principle remains the same.

These laws can be applied in programming to write clearer conditional statements. For example,

Consider this statement:

if not (x > y and y < z):

Using De Morgan’s Law, you can rewrite it as:

if not x > y or not y < z:

This implies that conditional statements can be written in different ways to the same effect. As seen in the above example, when negating a statement with and change it to or and negate each condition. For or, change it to and and negate each condition.

These transformations, while seemingly minor, make complex logical expressions clearer and easier to maintain in code.

Take a look at this loop condition:

while (selection != 'Q' || selection != 'q')

This loop condition appears logical but it has a flaw because the OR operator returns true if at least one of the conditions is true. This creates an infinite loop.

Using De Morgan’s second law:

while (selection != 'Q' && selection != 'q')

Now, the loop correctly exits when selection is either Q or q.

Apply De Morgan’s Law When:

Simplifying Nested Negations.

#Before
if not (a and b and not c):
    print("Condition met")
#After
if not a or not b or c:
    print("Condition met")

Writing Clearer Logical Expressions.

#Before
if (!(a && b)) { console.log("True"); }
#After
if (!a || !b) { console.log("True"); }

Both conditions evaluate the same way, but the second version is easier to read.

Conclusion
While you still need to understand the rules and precedence of logical operators, De Morgan's law provides clear methods to break down and improve logical expressions into more manageable forms that require less mental effort to understand.

So, the next time you find yourself dealing with nested conditions and negations, apply these two simple rules to clean up your logic and avoid unnecessary bugs.

For a more comprehensive reading on De Morgan's law and it's usage in logical expressions, check here.

DEV Community: Oluwawunmi Adesewa

How to Activate Claude Skills Automatically: 2 Fixes for 95% Activation

Table of Contents

Why Claude Skills Don't Trigger

Fix 1: Detection Hook + Trigger Rules

Step 1

Step 2 - Create the Hook Files

Step 2: Configure Skill Triggers

Step 3: Activate the Hook

How It Works

Fix 2: Forced Skill Evaluation

How Forced Skill Evaluation Works

How to Set it up

Which Method Should You Use?

Use Detection Hook (Fix 1) when:

Use Forced Evaluation (Fix 2) when:

Use Custom Instructions (Bonus) when:

Conclusion

Quick Troubleshooting

Shoutouts & References

Understanding Valibot: How it Works and When to Use it

A Few Things to Keep in Mind

Valibot Relies Heavily on Functional Programming Principles

What "Functional Programming Principles" Means in Valibot

1. Small, Pure Functions

2. Functional Composition and Data Pipelines

3. Immutability

Why This Modular Approach Has Several Benefits

Tree-shaking: The Bundle Size Revolution

Testability: Each Isolated Function is Easy to Test Thoroughly

Performance: Function Calls vs Method Lookups

Reusability Through Composition

This Changes How You Think About Validation

When This Approach Works Best

The Bottom Line

Further Reading

Best JavaScript Backend Automation Tools (With TypeScript Support)

Best JavaScript Backend Automation Tools (With TypeScript Support)

Table of Contents

Why Automate Backend Development in JavaScript

5 JavaScript Backend Automation Tools

Valibot: Automating Data Validation

Prisma: Automating Database Queries

Convex: Backend-as-a-Service with Automation Built In

ts-rest: Automating API Contracts and Clients

Fern: Automating SDKs and API Documentation

Picking the Right Backend Automation Tool

FAQ: JavaScript Backend Automation

Conclusion

How to Use ChatGPT for Coding: Prompts and Examples for Python, JavaScript, and More

Table of Contents

What Can ChatGPT Do for Developers?

1. Generate Code Snippets

2. Debug and Fix Errors

3. Explain Code in Plain English

4. Translate Between Programming Languages

5. Generate Tests

Best Prompt Practices for Developers

Always Include:

Bad Prompt:

Better Prompt:

Advanced Tip:

Real-World Use Cases by Language

Python

JavaScript / React

SQL

Bash

Debugging Code with ChatGPT

Example:

ChatGPT vs Copilot: Which Should You Use?

Limitations and Warnings

Don’t blindly trust the code

It has no live context

It doesn’t replace real experience

Frequently Asked Questions

Final Thoughts: ChatGPT Won’t Code for You But It Can Make You Faster

5 ChatGPT Prompting Techniques to Boost Developer Productivity

Table of Contents

1. Rolling Context Summaries

2. Prompt Structuring for Cleaner, Faster Output