Forem: Pooya Golchian

WhatsApp and Telegram Automation in Dubai: AI-Powered Bots for Business

Pooya Golchian — Tue, 07 Apr 2026 22:10:06 +0000

WhatsApp and Telegram Automation in Dubai

3.2 billion people use WhatsApp and Telegram daily. Your customers are already there. Your business should be too.

In Dubai, WhatsApp is not just a messaging app. It is the primary communication channel for business interactions across real estate, retail, hospitality, healthcare, and professional services. Customers expect instant responses. They expect to book, buy, and resolve issues without downloading another app or navigating another website.

Pooya Golchian builds intelligent bots and automation workflows that turn WhatsApp and Telegram into production-grade business channels.

Why Messaging Automation Matters for Dubai Businesses

Email open rates in the Gulf region average 18 to 22 percent. WhatsApp message open rates exceed 95 percent. The gap is not marginal. It is a completely different channel dynamic.

When a potential customer sends your business a WhatsApp message at 11 PM, the response window determines whether you close the deal or lose it to a competitor who replies faster. Manual teams cannot cover every hour. AI-powered bots can.

Pooya Golchian designs these systems so your business responds instantly, collects information intelligently, and routes conversations to humans only when the situation demands it.

What Gets Built

WhatsApp Business API integration connects your business to the official WhatsApp platform for transactional messages, customer support, interactive catalogs, and notification broadcasts at scale. This is not the basic WhatsApp Business App. It is the enterprise API that supports unlimited concurrent conversations.

Telegram bot development covers custom bots with inline keyboards, payment processing, group management, channel automation, and webhook-driven workflows. Telegram's bot ecosystem is more flexible than WhatsApp's, making it ideal for internal team tools and technical audiences.

AI-powered conversations use LLM-driven chatbots trained on your business data. These bots understand context, handle multi-turn conversations naturally, and know when to escalate to a human agent. They are not scripted decision trees. They are conversational AI that improves with every interaction.

n8n workflow automation connects messaging platforms to your entire tech stack through a visual workflow builder. CRM updates trigger WhatsApp messages. Form submissions start Telegram notification chains. Payment confirmations send receipts automatically. No-code configuration for business users. Custom code nodes for complex logic.

Multi-platform integration bridges WhatsApp and Telegram with your existing CRM, helpdesk, e-commerce platform, payment gateway, and analytics systems. Everything flows into a single view.

Use Cases That Drive Revenue

Customer support automation reduces ticket volume by 60 to 80 percent. Bots handle FAQs, order tracking, return requests, and account inquiries around the clock. Human agents handle only the conversations that require judgment.

Lead generation and qualification captures leads through conversational forms on WhatsApp. The bot qualifies prospects by asking the right questions, scores them based on responses, and routes hot leads to your sales team in real time.

Order and delivery notifications send transactional WhatsApp messages for order confirmation, shipping updates, delivery tracking, and post-delivery feedback collection. Open rates far exceed email for these critical touchpoints.

Appointment and booking bots let customers schedule, reschedule, and cancel through WhatsApp or Telegram with calendar integration and automated reminders. Clinics, salons, consultancies, and service businesses see immediate reduction in no-shows.

E-commerce catalog bots enable product browsing, cart management, and checkout flows entirely within WhatsApp, integrated with Shopify, WooCommerce, or custom backends.

Internal team automation uses Telegram bots for deployment triggers, monitoring alerts, daily standup automation, and cross-team notifications for engineering and operations teams.

Technology Stack

WhatsApp Business API, Telegram Bot API, n8n, Node.js, Python, LangChain, OpenAI, Twilio, Baileys, grammy.js, Redis, PostgreSQL, Webhook Processing, REST APIs, Docker, and Supabase.

Start Automating

Tell Pooya Golchian about your business, your customers, and your messaging goals. He will design the automation architecture and build it production-ready.

Based in Dubai. Serving businesses across the UAE and GCC.

Discuss your automation →

vue-star-rate: Zero-Dependency Vue 3.5+ Star Rating Component

Pooya Golchian — Tue, 07 Apr 2026 22:09:51 +0000

Star ratings sound simple until you ship them to production. Then you need half-star precision, accessible keyboard navigation, RTL layouts, flexible icon sources, and correct ARIA semantics. I built vue-star-rate to handle all of that in a single zero-dependency Vue 3.5+ component.

Documentation & Live Demo

Installation

pnpm add vue-js-star-rating

Requires Vue 3.5+. Uses defineModel and useTemplateRef, both stable in Vue 3.5. Zero runtime dependencies.

Basic Usage

<script setup lang="ts">

import 'vue-js-star-rating/dist/style.css';

const rating = ref(0);
</script>

<template>

</template>

Half-Star Ratings

The visual renderer fills exactly half of a star glyph. The emitted value is a decimal like 3.5.

Size Presets

  <!-- 16px -->
  <!-- 20px -->
  <!-- 24px, default -->
  <!-- 32px -->
  <!-- 40px -->
  <!-- Custom pixels -->

Custom Colors

Icon Providers

<!-- Lucide (requires lucide-vue-next) -->

<!-- FontAwesome (requires @fortawesome/fontawesome-free) -->

<!-- Fully custom SVG via slot -->

Read-Only Mode

For review cards, dashboards, and product pages:

Keyboard Navigation

Key	Action
Arrow Right / Up	Increase rating
Arrow Left / Down	Decrease rating
Home	Set to minimum
End	Set to maximum
1–9	Jump to specific value
0	Reset to minimum

The component uses role="group", aria-pressed on each star, and an aria-live counter, fully WCAG 2.2 compliant.

Tooltips and Counters

Full Configuration Example

<VueStarRate
  v-model="rating"
  :max-stars="5"
  :allow-half="true"
  :show-counter="true"
  :show-tooltip="true"
  size="lg"
  :colors="{ empty: '#27272a', filled: '#fbbf24', hover: '#fcd34d', half: '#fbbf24' }"
  :animation="{ enabled: true, duration: 200, type: 'scale' }"
  :clearable="true"
  @change="(val, old) => console.log(val, old)"
/>

Props Reference

Prop	Type	Default	Description
`v-model`	`number`	`0`	Rating value
`maxStars`	`number`	`5`	Maximum stars
`allowHalf`	`boolean`	`false`	Half-star precision
`size`	`xs / sm / md / lg / xl`	`md`	Size preset
`readonly`	`boolean`	`false`	Display-only mode
`clearable`	`boolean`	`false`	Clear button
`showCounter`	`boolean`	`false`	Numeric counter
`showTooltip`	`boolean`	`false`	Hover tooltips
`rtl`	`boolean`	`false`	Right-to-left layout
`iconProvider`	`custom / lucide / fontawesome`	`custom`	Icon source

Programmatic Control

const ratingRef = ref<InstanceType<typeof VueStarRate>>();

ratingRef.value?.reset();
ratingRef.value?.setRating(3.5);
ratingRef.value?.getRating();
ratingRef.value?.focus();

Migration from v2

v2	v3
`lucideIcons` prop	`icon-provider="lucide"`
`role="slider"`	`role="group"` (WCAG 2.2)
`animation: { scale: 1.15 }`	`animation: { type: 'scale' }`
Vue `^3.3.0` peer dep	Vue `^3.5.0` peer dep

GitHub · npm · Full Documentation

vue-multiple-themes v4: Dynamic Multi-Theme Support for Vue 2 & 3

Pooya Golchian — Tue, 07 Apr 2026 22:09:35 +0000

I have been building UIs with Vue for years and one pattern comes up constantly, you need more than dark/light. Clients want seasonal themes, brand-specific palettes, and accessibility-compliant contrasts. I extracted all of that into a standalone, typed library: vue-multiple-themes.

Full Documentation & Demo

What It Solves

The standard approach is toggling a .dark class on <html> and writing a wall of CSS overrides. That works for two themes. Scale to three or more and you get duplicated selectors, fragile specificity battles, and no tooling for generating accessible palettes.

vue-multiple-themes replaces that with:

CSS custom properties (--vmt-*) injected at the target element: every theme is a swap of values at one cascade layer
A reactive useTheme() composable accessible anywhere in the component tree
7 preset themes ready to use immediately
A TailwindCSS plugin that exposes those tokens as Tailwind utilities
WCAG color utilities for contrast checking, mixing, and palette generation: all SSR-safe

Installation

pnpm add vue-multiple-themes

Requires Vue 2.7+ or Vue 3. Zero runtime dependencies beyond Vue itself.

Quick Start: Vue 3


const app = createApp(App);
app.use(VueMultipleThemesPlugin, {
  defaultTheme: 'dark',
  strategy: 'attribute',
  persist: true,
});
app.mount('#app');

Then use useTheme() anywhere:

<script setup lang="ts">

const { currentTheme, setTheme, themes } = useTheme({ themes: PRESET_THEMES });
</script>

<template>
  <button v-for="t in themes" :key="t.name" @click="setTheme(t.name)">
    {{ t.label }}
  </button>
</template>

CSS Custom Properties

Once a theme is active, --vmt-* variables are available on <html>. Style components against them:

.card {
  background: var(--vmt-background);
  color: var(--vmt-foreground);
  border: 1px solid var(--vmt-border);
}

Switching themes updates every component instantly, no re-renders required.

The 7 Preset Themes

Name	Character
`light`	Clean white + indigo
`dark`	Dark gray + violet
`sepia`	Warm parchment browns
`ocean`	Deep sea blues
`forest`	Rich greens
`sunset`	Warm oranges & reds
`winter`	Icy blues & whites

Dynamic Theme Generation


const { light, dark } = generateThemePair('#6366f1');
const scale = generateColorScale('#6366f1', 9);

Ideal for SaaS products where each tenant sets a brand color and the full UI adapts automatically.

TailwindCSS Integration

const { createVmtPlugin } = require('vue-multiple-themes/tailwind');
module.exports = { plugins: [createVmtPlugin()] };

<div class="bg-vmt-surface text-vmt-foreground border-vmt-border">
  Themes itself automatically on switch
</div>

WCAG Utilities

Pure functions, no DOM, fully SSR-safe, tree-shakeable:


contrastRatio('#6366f1', '#ffffff');  // 4.54
autoContrast('#6366f1');              // '#ffffff'
checkContrast('#6366f1', '#ffffff');
// { ratio: 4.54, aa: true, aaa: false, aaLarge: true, aaaLarge: true }

`useTheme()` API

Option	Type	Default	Description
`themes`	`ThemeDefinition[]`	preset list	Available themes
`defaultTheme`	`string`	`light`	Initial theme
`strategy`	`attribute / class / both`	`attribute`	DOM application strategy
`persist`	`boolean`	`true`	Save to localStorage
`storageKey`	`string`	`vmt-theme`	localStorage key

Returns: { currentTheme, currentName, themes, setTheme, nextTheme, prevTheme }

Vue 2 Support


Vue.use(VueMultipleThemesPlugin, { defaultTheme: 'light' });

GitHub · npm · Full Documentation

Vibe Coding in 2026: $9.2B Cursor, 92% HumanEval, and the End of Boilerplate

Pooya Golchian — Tue, 07 Apr 2026 22:09:20 +0000

$9.2 billion. That is what investors valued Cursor's parent company Anysphere at in September 2025, after a $400M Series B. Bolt.new hit $2.1B. Lovable raised at $180M. Combined venture capital into vibe coding platforms exceeded $1 billion in 2025 alone.

Vibe coding stopped being a novelty sometime around Q2 2025. It became the default workflow. Andrej Karpathy coined the term in early 2024 to describe a paradigm where you tell the AI what you want in plain English and it writes the code. By March 2026, 82% of developers use or plan to use AI coding tools (GitHub Developer Survey). Enterprise adoption grew 340%. Non-technical user adoption surged 520% year-over-year.

This article breaks down the platforms, the pricing, the benchmarks, and the actual productivity math.

The Market Numbers

The total AI code generation market reached $4.2 billion in 2025 (MarketsandMarkets). The vibe coding segment, platforms that generate complete applications from natural language, now represents 25-30% of that market at an estimated $3-4.5 billion.

Growth projections sit at 38-42% CAGR through 2030, when the total market should hit $25 billion. The vibe coding segment grows faster than the broader market because it captures non-developer users that traditional coding assistants never reached.

Platform Landscape and Valuations

Six platforms dominate the market. Each targets a different workflow.

Cursor (Anysphere) raised $400M at a $9.2B valuation. It is a full IDE replacement built on VS Code's foundation with multi-agent AI orchestration for code generation, debugging, and refactoring. Cursor maintains separate planning, editing, and terminal agents communicating through a shared context window of up to 100,000 tokens.

GitHub Copilot holds the largest user base at 1.8 million paying subscribers and 55% market share among AI tool users. It operates inside existing IDEs rather than replacing them. The $10/month individual plan makes it the most accessible entry point.

Bolt.new (StackBlitz) runs entirely in the browser through WebContainers. No local setup. You describe an application, it generates and runs the code live. The $2.1B valuation reflects strong traction with designers and product managers who prototype without touching a terminal.

v0 (Vercel) specializes in frontend UI generation. 2 million users by Q1 2026 generate React components, landing pages, and entire application layouts from text descriptions. It integrates directly with Vercel's deployment pipeline.

Lovable targets full-stack web application generation with Supabase as the default backend. The $180M valuation after a $35M Series A positions it for teams that want complete applications, not just code snippets.

Replit Agent processes over 50 million code executions monthly in its cloud environment. The agent handles project setup, dependency management, deployment, and iteration in a single conversational thread.

Pricing Breakdown

Every platform uses tiered pricing. The free tiers are generous enough for evaluation. The enterprise tiers add team management, SSO, and usage controls.

GitHub Copilot offers the lowest entry point at $10/month. Cursor and Bolt.new cluster at $20/month for individual Pro plans. Enterprise pricing diverges sharply. Cursor charges $90/month per seat, while GitHub Copilot Enterprise sits at $39/month.

The hidden costs matter more than subscription fees. Integration time, team training, and infrastructure for self-hosted models add 15-30% to the visible platform cost. Organizations running hybrid setups with both cloud and local models should budget for the operational overhead.

AI Model Benchmarks

The model powering the platform determines code quality. HumanEval, the standard benchmark for code generation, reveals meaningful differences.

Claude 3.5 Sonnet leads at 92.4%, which translates to generating correct solutions for 92 out of 100 programming challenges on the first attempt. GPT-4o follows at 90.2%. Google's Gemini Code Assist scores 88.5%. The gap between commercial and open source narrows. DeepSeek Coder achieves 86.7% at a fraction of the inference cost.

Context window size determines how much of your codebase the model can understand simultaneously. Claude 3.5 Sonnet supports 200K tokens. GPT-4o handles 128K. Larger context windows mean better suggestions because the model sees more of your project structure, dependencies, and coding patterns.

Multi-agent architectures in platforms like Cursor assign different models to different tasks. A planning agent decomposes your request. An editing agent generates code. A review agent catches errors. This specialization outperforms single-model approaches for complex multi-file changes.

Productivity Impact

The research data comes from multiple sources: a 2024 Posit study, Microsoft's internal engineering metrics, and aggregated developer surveys.

Coding tasks complete 30-55% faster with AI assistance. The range depends on task complexity. Routine CRUD operations and boilerplate see the highest gains. Novel algorithm design shows smaller improvements because the model lacks context that the developer holds in their head.

Documentation responds best to vibe coding at a 65% time reduction. The AI generates docstrings, README sections, and API documentation from existing code with minimal correction needed. Sprint completion improves 40% according to Microsoft's internal data.

Code defects drop 15% with AI-assisted review. This counterintuitive result happens because the AI catches patterns that developers overlook during manual review, particularly null checks, edge cases in error handling, and inconsistent type usage.

Startups report 2-3x faster MVP development. The advantage compounds when the founding team includes non-technical members who can iterate on prototypes directly using platforms like v0 or Lovable.

Enterprise Adoption Trajectory

Enterprise adoption grew 340% from 2024 to early 2026. The S-curve is now hitting the steep middle section.

82% of developers use or plan to use AI coding tools. That figure from the GitHub Developer Survey represents saturation at the individual level. The enterprise transition lags because it requires security review, compliance approval, and integration with existing CI/CD pipelines.

Non-technical user adoption grew 520% year-over-year. Platforms like v0 and Lovable absorb users who previously depended on no-code tools like Webflow or Bubble. The output quality from vibe coding surpasses no-code platforms because it generates actual production-ready code rather than proprietary markup.

Financial services and healthcare move slowest due to data governance requirements. Technology and media companies adopted fastest. The gap narrows as platforms add SOC 2 compliance, on-premises deployment options, and audit logging.

What Changes Next

Three trends will reshape vibe coding through 2027.

Model commoditization. Open source models close the quality gap with commercial offerings. DeepSeek Coder already scores within 6 points of Claude 3.5 Sonnet on HumanEval. When model quality becomes a non-factor, platform differentiation shifts entirely to developer experience, integrations, and ecosystem.

Agent autonomy. Current platforms still require human guidance for complex tasks. The next generation will handle multi-step workflows autonomously: read the bug report, identify the root cause, write the fix, run the tests, open the pull request. Early versions of this workflow exist in Cursor and Replit Agent today.

Regulatory pressure. Generated code inherits copyright and licensing questions that remain unresolved. The EU AI Act includes provisions for AI-generated content transparency. Companies using vibe coding at scale will need audit trails showing which code was human-written versus AI-generated.

The $25 billion projected market by 2030 assumes these trends accelerate. Every developer becomes more productive. Every non-developer gains the ability to build functional software. The economic value creation from that shift dwarfs the platform revenue numbers.

Vibe coding data sourced from MarketsandMarkets AI Code Generation Report 2025, Gartner AI Developer Tools Forecast Q4 2025, GitHub Developer Survey 2026, Posit Developer Productivity Study 2024, and Redmonk Developer Survey 2026.

Subscribe to get new research articles with data visualizations

use-local-llm: React Hooks for AI That Actually Work Locally

Pooya Golchian — Tue, 07 Apr 2026 22:09:05 +0000

You've finally got your local LLM running. You pull a model, test it with curl, and it works beautifully. But the moment you try to integrate it into your React app, you hit a wall.

The tools everyone uses assume you're calling OpenAI or Anthropic from a server. They don't expect you to talk to localhost:11434 directly from the browser. And if they do, they force you to build API routes, add a backend, and complicate your prototype.

I kept running into this frustration, so I built use-local-llm, a library with a single purpose. It streams AI responses from local models directly in the browser with no backend, in 2.8 KB of code and zero dependencies.

Why Existing Tools Don't Fit

You'd think you could just use Vercel AI SDK. It's the standard for React + AI. It ships adapters for multiple frameworks, maintains thorough API references, and handles production traffic at scale.

But Vercel did not build it for direct browser-to-localhost communication.

Vercel AI SDK requires an API layer. Your React app POSTs to your Next.js server, which then calls the LLM and streams back. This makes sense for production apps using OpenAI or Anthropic, because you need the backend for authentication, cost tracking, and security.

But when the LLM is already running locally on localhost:11434, that server adds nothing but friction. More code to write. More latency. More complexity for something that should be a quick prototype.

I wanted one thing. A single React hook that talks directly to my local model. No middleman. No API routes. Just React and a running LLM.

Browser → fetch() → localhost:11434 → streaming tokens back

That is the entire architecture. No intermediary.

How It Works

use-local-llm gives you React hooks that stream responses from local LLMs directly in the browser. No API routes. No backend. Just one hook and your running model.

Here's what a complete, production-ready chat interface looks like in practice.

One Hook. That's It.


function Chat() {
  const { messages, send, isStreaming } = useOllama("gemma3:1b");

  return (
    <div>
      {messages.map((m, i) => (
        <p key={i}>
          <strong>{m.role}:</strong> {m.content}
        </p>
      ))}
      <button onClick={() => send("Hello!")} disabled={isStreaming}>
        {isStreaming ? "Generating..." : "Send"}
      </button>
    </div>
  );
}

That's it. That's a complete, streaming chat interface. Message history? Handled. Streaming state? Handled. Stopping mid-generation? Handled. All the complexity is wrapped inside the hook.

No /api/chat route. No Next.js. No backend configuration. Just React doing what it does best.

Works With Any Local LLM

Whether you're using Ollama, LM Studio, llama.cpp, or any OpenAI-compatible server, the same API applies.


const ollama = useLocalLLM({ endpoint: "http://localhost:11434", model: "gemma3:1b" });
const lmStudio = useLocalLLM({ endpoint: "http://localhost:1234", model: "local-model" });
const llamaCpp = useLocalLLM({ endpoint: "http://localhost:8080", model: "model" });

The library detects the backend from the port. Each uses its native streaming protocol, so you get optimal performance regardless of which tool you chose.

Advanced: Token-by-Token Control

Need fine-grained control? You can hook into every token as it arrives.


function Writer() {
  const { output, generate, isStreaming } = useStreamCompletion({
    endpoint: "http://localhost:11434",
    model: "gemma3:1b",
    onToken: (token) => console.log("Token:", token),
  });

  return (
    <div>
      <pre>{output}</pre>
      <button onClick={() => generate("Write a haiku about React")}>
        Generate
      </button>
    </div>
  );
}

Discover Available Models

Let your users pick from available models without manual configuration:


function ModelPicker() {
  const { models, isLoading } = useModelList();

  return (
    <select>
      {models.map((m) => (
        <option key={m.name} value={m.name}>{m.name}</option>
      ))}
    </select>
  );
}

How It Compares

Vercel AI SDK is fantastic for production apps using cloud APIs. But for local development, the architectures diverge:

	Vercel AI SDK	use-local-llm
For	Cloud LLMs (OpenAI, Anthropic, etc.)	Local LLMs (Ollama, LM Studio, llama.cpp)
Architecture	Client → Server → Cloud API	Client → Local LLM directly
Backend needed	Yes (required)	No
Setup time	10+ minutes	2 minutes
Bundle size	~50 KB+	2.8 KB
Dependencies	Multiple	Zero (React only)
Privacy	Data leaves your machine	Never leaves your machine

Pick the tool for your use case. If you're calling OpenAI in production, use Vercel AI SDK. If you're prototyping locally or prioritizing privacy, use use-local-llm.

Why It's Built This Way

Zero Dependencies (2.8 KB Total)

The entire package is 2.8 KB gzipped. No runtime dependencies. Only React as a peer.

Why does this matter? Your prototype should install instantly and never conflict with anything else in your project. No dependency conflicts. No version mismatches. No bloat.

Works Outside React Too

The core streaming functions (streamChat() and streamGenerate()) are async generators that run in any JavaScript environment, from React and Vue to vanilla JS and Node.js scripts. Use the hooks for React apps or the generators directly for everything else.


const stream = streamChat({
  endpoint: "http://localhost:11434",
  model: "gemma3:1b",
  messages: [{ role: "user", content: "Hello" }],
});

for await (const chunk of stream) {
  process.stdout.write(chunk.content);
}

AbortController Integration

Every stream is cancellable immediately. User-initiated aborts do not trigger error states, because aborting a generation is a normal user action, not an error.

Full TypeScript Support

Everything is strongly typed. IDE autocompletion, type safety, and explicit contracts cover every function.

import type {
  Backend,        // "ollama" | "lmstudio" | "llamacpp" | "openai-compatible"
  ChatMessage,    // { role: "system" | "user" | "assistant", content: string }
  StreamChunk,    // { content: string, done: boolean, model?: string }
  LocalModel,     // { name, size?, modifiedAt?, digest? }
} from "use-local-llm";

Architecture

┌─────────────────────────────────────────────────┐
│  Your React App                                 │
│                                                 │
│  useOllama("gemma3:1b")                         │
│        │                                        │
│        ▼                                        │
│  useLocalLLM({ endpoint, model, ... })          │
│        │                                        │
│        ▼                                        │
│  streamChat() / streamGenerate()                │
│        │          async generators              │
│        ▼                                        │
│  parseStreamChunk()                             │
│        │          NDJSON + SSE parser            │
│        ▼                                        │
│  fetch() + ReadableStream                       │
└─────────┬───────────────────────────────────────┘
          │ HTTP (no server in between)
          ▼
┌─────────────────────┐
│  Ollama    :11434   │
│  LM Studio :1234    │
│  llama.cpp :8080    │
└─────────────────────┘

Each layer is independently testable. The hooks compose on top of pure functions that can run anywhere.

When to Reach for use-local-llm

Perfect for:

🚀 Rapid prototyping that puts AI streaming in your React app in 2 minutes, not 20
🔒 Privacy-first apps where data never leaves your machine. No cloud API calls. No tracking
🏢 Enterprise/offline deployments that run in air-gapped networks and disconnected environments
🎓 Learning how LLM streaming works without server boilerplate
⚡ Small footprint for projects where bundle size and dependency count matter

Skip this library if:

You're using OpenAI, Anthropic, or other cloud APIs in production
You need server-side authentication, logging, or rate limiting
Your app is already using Vercel AI SDK for other reasons

Start Building

Step 1: Install the library

npm install use-local-llm

Step 2: Start your local LLM

ollama serve

Step 3: Stream AI in your React app (see examples above)

That's it. No API routes. No server configuration. AI streaming in your browser in under 2 minutes.

Learn more:

Full Documentation — API reference, advanced patterns, troubleshooting
Live Demo — See it working with Ollama
GitHub — Source code, issues, contributions
npm Package — Install it

TypeScript 6.0: New Features Every Developer Should Know

Pooya Golchian — Tue, 07 Apr 2026 22:08:49 +0000

TypeScript 6.0 has arrived. The latest major release brings substantial performance improvements, refined type inference, and developer experience enhancements that address long-standing community requests.

Microsoft announced TypeScript 6.0 on March 20, 2026, marking a significant milestone in the language's evolution. With over 50 million weekly npm downloads and adoption by 95% of JavaScript developers in enterprise environments, TypeScript continues to shape how modern web applications are built Microsoft DevBlog, 2026.

Performance Improvements: Faster Compilation

TypeScript 6.0 delivers measurable performance gains across the compilation pipeline.

Incremental Compilation Speedup: Projects using incremental compilation see 40-60% faster rebuild times. The compiler now caches type resolution results more aggressively, reducing redundant work during watch mode.

Memory Usage Reduction: Peak memory consumption during compilation drops by approximately 25% for large codebases. This improvement stems from optimized internal data structures and garbage collection patterns.

Editor Responsiveness: Language service operations, including autocomplete and error checking, complete 30% faster on average. Developers experience less lag when working with large monorepos.

Enhanced Type Inference

TypeScript 6.0 introduces smarter type inference that reduces the need for explicit type annotations.

Contextual Typing for Array Methods: Array methods like map, filter, and reduce now infer more precise return types based on usage context. Previously required explicit generics are now often unnecessary.

// TypeScript 5.x: Required explicit type annotation
const numbers: number[] = [1, 2, 3];
const doubled = numbers.map(n => n * 2); // inferred as number[]

// TypeScript 6.0: Smarter literal type inference
const config = {
  mode: 'production', // inferred as literal 'production', not string
  port: 3000          // inferred as literal 3000, not number
};

Improved Generic Inference: Generic type parameters are inferred more accurately in complex scenarios involving multiple type parameters and constraints.

Control Flow Analysis: Narrowing types through control flow analysis now works across more edge cases, including async/await patterns and generator functions.

New Language Features

TypeScript 6.0 introduces several language features that enhance expressiveness and type safety.

Explicit Resource Management: The using declaration provides automatic cleanup for disposable resources, similar to C#'s using statement or Python's context managers.

using file = await openFile('data.txt');
// file is automatically closed when scope exits

Decorator Metadata: Stage 3 decorators now support metadata attachment, enabling frameworks to access type information at runtime. This powers dependency injection, validation, and serialization libraries.

Import Attributes: Import assertions evolve into import attributes, providing a standard way to specify module import conditions.

import data from './data.json' with { type: 'json' };

Developer Experience Enhancements

TypeScript 6.0 focuses heavily on improving the day-to-day developer experience.

Better Error Messages: Error messages now include suggested fixes for common mistakes. The compiler detects likely typos and suggests corrections based on available identifiers.

Go to Source Definition: A new editor command jumps directly to the JavaScript source of a library, not just its type declarations. This aids debugging and understanding third-party code.

Inlay Hints Improvements: Parameter name and type inlay hints are more configurable and performant. Large files no longer cause editor slowdowns when hints are enabled.

JSDoc Support: JavaScript projects using JSDoc for type annotations benefit from improved type inference and error detection, narrowing the gap between JavaScript and TypeScript development.

Breaking Changes and Deprecations

TypeScript 6.0 includes minimal breaking changes, maintaining the team's commitment to backward compatibility.

Stricter Generic Checks: Some edge cases involving generic constraints now produce errors where they previously passed. These changes catch potential runtime bugs.

Deprecated Features: The tsconfig.json suppressExcessPropertyErrors option is deprecated in favor of more granular control. The noImplicitUseStrict option is removed, as modules are strict by default in modern JavaScript.

Lib Updates: DOM type definitions are updated to reflect the latest web standards. Some deprecated APIs are removed from the default library.

Migration Guide: Upgrading to TypeScript 6.0

Upgrading existing projects to TypeScript 6.0 is straightforward for most codebases.

Step 1: Update Dependencies

npm install typescript@^6.0.0 --save-dev
# or
yarn add typescript@^6.0.0 --dev

Step 2: Review Compiler Options

Check your tsconfig.json for deprecated options. Update or remove suppressExcessPropertyErrors and noImplicitUseStrict if present.

Step 3: Address New Errors

Run the compiler and fix any new type errors. Most projects require minimal changes. Focus on generic constraint violations first.

Step 4: Enable New Features

Consider enabling new strictness flags incrementally. Start with strictFunctionTypes and noUncheckedIndexedAccess for maximum safety.

Step 5: Update Tooling

Ensure your IDE, build tools, and linting configurations support TypeScript 6.0. Most popular tools update within days of release.

Ecosystem Impact

TypeScript 6.0's release triggers updates across the JavaScript ecosystem.

Framework Updates: React, Vue, Angular, and Svelte release patches leveraging new TypeScript features. Framework-specific type definitions become more precise.

Build Tool Support: Vite, Webpack, esbuild, and Rollup update their TypeScript integrations to support new language features and optimize for performance improvements.

Library Maintenance: Popular libraries like lodash, RxJS, and date-fns update their type definitions. Community-maintained @types packages follow suit.

Testing Frameworks: Jest, Vitest, and Playwright enhance their TypeScript support, improving type inference for test matchers and fixtures.

Comparison with Alternative Typed Languages

TypeScript 6.0 strengthens its position against alternatives.

Deno: Deno's native TypeScript support remains compelling for new projects, but TypeScript 6.0 narrows the gap with improved performance and features.

JSDoc: JavaScript with JSDoc annotations becomes more viable for teams avoiding build steps, thanks to TypeScript 6.0's enhanced JavaScript support.

Flow: Flow's niche shrinks further as TypeScript's ecosystem dominance grows. Most Flow projects have migrated or are planning migrations.

ReScript: ReScript maintains its position for performance-critical applications, but TypeScript 6.0's speed improvements reduce the performance gap.

FAQ

Is TypeScript 6.0 backward compatible?

Yes, TypeScript 6.0 maintains strong backward compatibility. Most projects upgrade without code changes. A small number of edge cases involving generic constraints may require adjustments TypeScript Documentation, 2026.

How much faster is TypeScript 6.0?

Benchmarks show 40-60% faster incremental compilation, 25% reduced memory usage, and 30% faster editor operations. Actual improvements vary based on project size and complexity. Large monorepos benefit most significantly.

What is the using declaration?

The using declaration enables automatic resource cleanup. When a variable declared with using goes out of scope, its [Symbol.dispose]() method is called. This simplifies resource management for files, network connections, and locks TC39 Proposal, 2025.

Do I need to update my tsconfig.json?

Review your configuration for deprecated options. Remove suppressExcessPropertyErrors and noImplicitUseStrict if present. Consider enabling new strictness flags for improved type safety. Most existing configurations work without changes.

When will frameworks support TypeScript 6.0?

Major frameworks typically release TypeScript 6.0 support within one week of release. React, Vue, Angular, and Svelte have already published compatible versions. Check your framework's changelog for specific version requirements.

Can I use TypeScript 6.0 with Node.js?

Yes, TypeScript 6.0 supports all maintained Node.js versions (18.x, 20.x, 22.x). The TypeScript compiler targets JavaScript output compatible with your specified Node.js version through the target compiler option.

What are decorator metadata?

Decorator metadata allows decorators to access type information at runtime. This enables frameworks to implement dependency injection, validation, and ORM mapping with full type safety. The feature uses the Stage 3 decorators proposal TypeScript Handbook, 2026.

Conclusion

TypeScript 6.0 represents a mature evolution of the language. Performance improvements address long-standing pain points for large projects. Enhanced type inference reduces boilerplate while maintaining safety. New language features align TypeScript with modern JavaScript proposals.

For developers, upgrading is low-risk and high-reward. The migration path is smooth, and the benefits are immediate. Faster compilation, better editor support, and improved type inference enhance daily productivity.

For organizations, TypeScript 6.0 solidifies the language's position as the standard for enterprise JavaScript development. The ecosystem continues to grow, with tooling and library support expanding.

The future of web development remains typed. TypeScript 6.0 ensures that future is faster, safer, and more developer-friendly than ever before.

Pooya Golchian is an AI Engineer and Full Stack Developer specializing in TypeScript and React applications. Follow him on Twitter @pooyagolchian for more insights on modern web development.

Supply Chain Attacks on Developers: Lessons from LiteLLM and Trivy

Pooya Golchian — Tue, 07 Apr 2026 22:08:33 +0000

Supply chain attacks on developers have escalated dramatically in early 2026. Two major incidents, LiteLLM and Trivy, exposed thousands of projects to credential theft, backdoors, and potential data breaches.

These attacks represent a fundamental shift in how threat actors target software development. Instead of attacking finished applications, they compromise the tools developers use to build them.

The LiteLLM PyPI Compromise

In March 2026, malicious versions of LiteLLM appeared on PyPI, affecting thousands of Python projects.

What Happened:

Versions 1.82.7 and 1.82.8 of LiteLLM contained credential theft mechanisms and persistent backdoors. The attack was sophisticated, using obfuscated code and delayed execution to evade detection.

Attack Mechanism:

The malicious code activated 24 hours after installation, making it harder to correlate with the package update. It exfiltrated environment variables, including API keys and database credentials, to attacker-controlled servers.

Impact:

Over 15,000 projects downloaded the compromised versions before discovery. Major organizations using LiteLLM for LLM abstraction had to rotate credentials and audit access logs.

Discovery:

Security researchers at FutureSearch.ai identified the compromise through behavioral analysis. The malware attempted network connections to unusual domains, triggering automated alerts FutureSearch.ai, 2026.

The Trivy GitHub Actions Compromise

Trivy, a popular container vulnerability scanner, was compromised through its GitHub Actions integration.

Attack Vector:

Threat actors gained access to Trivy's GitHub repository and pushed malicious tags. These tags were picked up by CI/CD pipelines worldwide, executing attacker-controlled code in build environments.

Scope:

The compromise affected any project using Trivy GitHub Actions with floating version tags. CI/CD secrets, including cloud provider credentials and deployment tokens, were exposed.

Exploitation:

The malicious code ran with the permissions of the CI/CD pipeline. In many cases, this included write access to container registries, production deployments, and infrastructure management.

Response:

Socket.dev and other security firms coordinated disclosure. GitHub revoked compromised tokens and worked with maintainers to secure the repository Socket.dev, 2026.

How Supply Chain Attacks Work

Understanding attack vectors is essential for defense.

Typosquatting:

Attackers publish packages with names similar to popular libraries. Developers mistype imports and install malware. Examples include reqeusts instead of requests, djano instead of django.

Dependency Confusion:

Public packages with the same name as internal packages take precedence in some package managers. Attackers upload public versions with higher version numbers, tricking build systems.

Compromised Maintainer Accounts:

Phishing attacks on package maintainers give attackers legitimate publishing credentials. These attacks are hard to detect since the packages come from trusted sources.

Build System Compromise:

Attackers target the infrastructure that builds packages. This was the vector for the Trivy compromise and the 2024 XZ Utils backdoor attempt.

Malicious Updates:

Legitimate packages are compromised and used to distribute malware. The LiteLLM attack followed this pattern, with attackers gaining access to the PyPI publishing pipeline.

Protecting Your Projects

Defense requires multiple layers of security.

Pin Dependencies:

Use exact version numbers in requirements files. Avoid floating versions like package>=1.0. Pin to specific hashes where possible.

# requirements.txt with hashes
litellm==1.82.6 \
    --hash=sha256:abc123...

Private Registries:

Mirror public packages to private registries you control. Scan packages before internal distribution. This adds a review layer between public repositories and your builds.

Automated Scanning:

Integrate security scanning into CI/CD pipelines. Tools like Snyk, Socket.dev, and GitHub Advanced Security detect known malicious packages and vulnerable dependencies.

Least Privilege:

Run CI/CD pipelines with minimal permissions. Separate build, test, and deployment credentials. Use short-lived tokens with limited scope.

Dependency Review:

Audit new dependencies before adding them. Check maintainer reputation, update frequency, and community adoption. Avoid abandoned or single-maintainer projects for critical functionality.

Industry Response and Best Practices

The security community has responded with new tools and standards.

Software Bills of Materials (SBOM):

SBOMs inventory all dependencies and their versions. They enable rapid vulnerability assessment when new threats emerge. Executive Order 14028 mandates SBOMs for software sold to the US government.

Sigstore and Artifact Signing:

Sigstore provides free certificate authority and transparency logs for software artifacts. Signed packages can be verified against tampering. Adoption is growing across major package registries.

Package Manager Improvements:

PyPI, npm, and other registries have implemented stricter authentication, mandatory 2FA for maintainers, and malware scanning. These measures reduce but do not eliminate risk.

Security Frameworks:

NIST SSDF, OWASP SAMM, and SLSA provide frameworks for secure software development. Following these standards reduces supply chain attack surface.

The Economic Impact

Supply chain attacks have measurable business consequences.

Remediation Costs:

The average supply chain breach costs $4.5 million to remediate. This includes credential rotation, forensic analysis, legal fees, and reputation damage.

Development Velocity:

Security reviews slow development. Teams spend 15-20% more time on dependency management and security audits post-incident.

Insurance:

Cyber insurance premiums have increased 50% for software companies. Insurers now require SBOMs, dependency scanning, and incident response plans.

Regulatory:

The SEC now requires public companies to disclose material cybersecurity incidents within four days. Supply chain attacks affecting customer data trigger these disclosures.

FAQ

What is a supply chain attack?

A supply chain attack targets the tools, libraries, and services used to build software rather than the final application. By compromising upstream dependencies, attackers gain access to all downstream projects. These attacks are difficult to detect since the malicious code comes from trusted sources CISA, 2026.

How can I check if my project is affected?

Audit your dependency files (requirements.txt, package.json, Cargo.toml) for compromised versions. Use pip list or npm list to see installed packages. Security tools like Snyk and GitHub Dependabot alert on known malicious versions automatically.

What should I do if I used a compromised package?

Immediately rotate all credentials that may have been exposed. Check logs for unauthorized access. Update to clean versions of the package. Audit your codebase for signs of compromise. Notify security teams and affected users if sensitive data was accessed.

Are private package registries safer?

Private registries add a layer of control but are not inherently safer. They must be maintained, scanned, and updated like public registries. The benefit is the ability to review packages before internal distribution and control update timing.

How do I prevent dependency confusion attacks?

Use scoped packages (e.g., @company/package) for internal libraries. Configure package managers to prioritize private registries. Implement namespace reservation on public registries for your organization.

What is the future of supply chain security?

Expect mandatory code signing, SBOM requirements, and automated vulnerability scanning to become standard. Supply chain security will be integrated into DevSecOps pipelines by default. Regulatory requirements will drive adoption of secure development practices.

Conclusion

The LiteLLM and Trivy compromises are warnings, not anomalies. Supply chain attacks are increasing in frequency and sophistication. Development teams must treat dependencies as potential attack vectors.

The solution is not to avoid third-party code. Modern software development depends on open source. The solution is to manage dependencies with security in mind.

Pin versions. Scan for vulnerabilities. Use private registries. Implement least privilege. Build SBOMs. Sign artifacts. These practices add friction but prevent catastrophe.

The attackers are targeting your tools. Secure them before they do.

Pooya Golchian is an AI Engineer and Full Stack Developer specializing in secure software development. Follow him on Twitter @pooyagolchian for more insights on cybersecurity and development.

State of the Product Job Market in Early 2026

Pooya Golchian — Tue, 07 Apr 2026 22:08:18 +0000

The job market statistics tell one story. Candidates tell another.

Over 7,300 product management roles are open globally right now — the highest count in three years. Engineering has 67,000 open positions. AI-specific roles grew 340% since 2024. By every headline metric, the tech hiring market is in recovery. Yet talk to anyone who has been searching for six months, and you hear something different: a market that moves fast for the right profile and goes silent for everyone else.

Both stories are true. This is a selective recovery, not a broad one, and the selection criteria shifted fast.

The PM Numbers

Lenny Rachitsky's biannual State of the Product Job Market report is the most systematic tracking of PM openings available, drawing from data across over 9,000 tech companies worldwide. The early 2026 edition recorded the most optimistic outlook across four consecutive reports. Over 7,300 open PM roles globally represent a 75% increase from the 2023 lows and roughly 20% growth since the start of this year alone. One finding stands out beyond the headline count: Growth PM is now the single fastest-growing PM role category, outpacing even AI-adjacent titles in open requisitions.

That number has a context problem, though. The absolute count feels strong until you compare it to application volumes. Generalist PM roles at mid-market companies attract hundreds of applicants within days of posting. Senior IC and leadership roles, by contrast, sit open for months because qualified candidates are scarce. The same data set produces two completely different job-search experiences depending on which tier you compete in.

Engineering's Comeback

The engineering numbers are even more striking. Yahoo Finance's analysis of tech hiring data puts total open engineering roles above 67,000 globally — 26,000 in the U.S. alone. Software engineering job postings grew 11% year-over-year. Supply simply has not kept pace: three engineering jobs exist for every qualified candidate.

Lenny Rachitsky's data — drawn from over 9,000 tech companies worldwide — shows the engineering rebound as part of a broader industry expansion. The global software development market hit $640 billion in 2026 and analysts project it reaching $1.11 trillion by 2031 at an 11.74% compound annual growth rate. That trajectory demands engineers, not fewer of them.

This mismatch is not evenly distributed across engineering disciplines. Generalist web and mobile engineering roles remain competitive. Roles requiring Python, cloud infrastructure (AWS), API design, and CI/CD pipeline expertise see the most intense demand. Companies cannot hire fast enough in those areas, while applications for JavaScript-generalist roles stack up in recruiters' inboxes.

The AI Wedge

The most disruptive force in this market is not the hiring recovery. It is the structural bifurcation AI is creating inside every job category.

AI-related job postings increased 340% since 2024, according to InformationWeek's 2026 layoff and hiring tracker. Traditional software engineering roles declined 15% over the same period. Atlassian made this dynamic explicit when it cut 1,600 generalist positions while simultaneously opening 800 AI-focused roles. The headcount math looks like a modest net reduction. The skill-set math is a complete reset.

IEEE-USA's 2026 tech hiring outlook projects the roles with the fastest growth as AI governance officers, AI workflow leads, AI agent orchestrators, and machine learning engineers. None of these categories existed at meaningful scale three years ago. Companies are now realizing that reskilling timelines for their existing workforce run 18 to 24 months, while competitive pressure requires these capabilities now. The result is a surplus of applicants for roles companies are quietly defunding and a severe shortage in the specialized space that is actually growing.

What This Market Pays

Compensation data across multiple sources paints a consistent picture. The median PM salary in the U.S. sits at $149,871 to $159,405 annually, per Leland's 2026 PM salary benchmarks.

By experience level:

Level	Years	Base Salary Range
Entry	0–2 yrs	$80,000 – $110,000
Mid	3–7 yrs	$120,000 – $160,000+
Senior	7+ yrs	$160,000 – $210,000+
AI PM	Any	$130,000 – $200,000 base

Total compensation at top-tier firms extends further. Simplilearn's AI PM salary data puts total comp for AI product roles at $180,000 to $260,000 including bonuses and equity. Bay Area senior PMs regularly see $250,000+ total packages.

Ravio's compensation trend analysis adds useful color on the growth trajectory: median PM salary increases reached 5.2% in 2025, the strongest growth across all job functions tracked. Late-stage companies pay 14% more than early-stage for mid-level PMs and 34% more for senior roles — a premium worth factoring into any job search.

Where the Jobs Actually Are

Geography matters more in 2026 than it did during the remote-work peak of 2021 to 2023. The Bay Area holds 23% of all global PM openings, a figure that has grown 50% since 2022. New York ranks second. One-third of every AI-specific role sits in the Bay Area, according to Lenny's data.

Remote opportunities are declining even as overall job counts grow. Companies that expanded their geographic hiring aperture during the pandemic are contracting it. This creates a specific trap for candidates who structured their life around remote flexibility: more jobs on paper, fewer jobs they can actually take.

Design's Divergence

One of the more telling signals in Rachitsky's report is what design is not doing. Open design roles sit around 5,700 globally — essentially flat since early 2023 while PM and engineering counts surged. The PM-to-designer demand ratio shifted from near parity in mid-2023 to 1.27x today.

AI is absorbing design workflow tasks faster than it is absorbing PM or engineering tasks. Wireframing, asset generation, and iteration cycles that previously required a dedicated designer now move through AI tooling in hours. The demand signal is clear and companies are responding to it.

Levie's Counterargument

Box CEO Aaron Levie made the case for optimism in a Yahoo Finance interview. His argument deserves attention precisely because it runs against the prevailing anxiety. "There are few examples of AI replacing an entire job," Levie said. The more likely outcome, in his framing, is that AI-driven productivity makes companies grow faster, which creates downstream demand for more hires to support that growth.

The counterweight comes from KPMG chief economist Diane Swonk, who flagged the possibility of a "jobless boom" in 2026 — firms achieving more output with fewer workers, without those productivity gains translating into new headcount. Both positions carry historical precedent. The difference between them will likely come down to whether AI-fueled revenue growth is concentrated in a few sectors or distributed broadly across the economy.

The Selective Recovery

The 2026 tech job market does not reward the same behaviors that worked in 2019 or 2021. Companies hiring right now do so with precision — every open role ties directly to revenue generation, risk reduction, or AI adoption. Generalist headcount is the first thing frozen when planning tightens.

Senior PMs with demonstrated AI-adjacent impact, engineers holding Python and AWS depth, and candidates willing to operate in-office in the Bay Area sit in high demand. Junior PMs face the sharpest competition: fewer entry-level openings, more applicants, and a bar that has moved up. Candidates locked to remote-only roles face a structural disadvantage that grew more pronounced through 2025 and continues in 2026.

The optimixed.com analysis of Rachitsky's report notes a key structural reality: despite record PM openings, tech job postings overall remain 35% below pre-pandemic February 2020 levels. The recovery is real, but it is recovering toward a different baseline — one where every role needs a stronger justification to exist and every hire needs a faster path to measurable output.

The Tooling Argument

Ben Halpern, co-founder of Forem (the company behind dev.to), published a sharp counter-narrative to the doom loop in a March 2026 essay. His argument: the industry is moving through a cost-cutting middle phase driven by AI implementation, and substantial growth will follow once tooling matures. "Tooling is getting there to the point where there will be renewed growth — for developers with a handle on how to leverage their skills and knowledge for AI-driven development," Halpern writes.

The more interesting question his essay surfaces is not whether growth returns but what kind of growth. Community responses to the piece flagged a real challenge: teams are no longer limited by tool maturity but by knowing what to build differently when AI handles the routine work. That question — what to build, not how fast to build it — is a product management question. It is exactly the gap the current surge in PM demand is trying to fill.

What to Do With This

Position yourself inside the AI skill gap rather than outside it. Generalist experience is a foundation, not a differentiator. The candidates winning in this market reframe their background in terms of AI-adjacent impact — where they accelerated AI adoption, reduced the cost of AI implementation, or translated AI capabilities into product decisions.

Target late-stage companies. The 14% to 34% salary premium over early-stage is real, and late-stage companies have clearer revenue models that justify headcount. Bay Area optionality, even partial, opens up one-third of the most active AI hiring market in the world. And treat the AI skill mismatch as an opening, not a threat — because right now, the most acute problem tech companies have is not too many applicants. It is that they cannot find enough people who understand both product and AI systems well enough to move fast.

That gap will not stay open indefinitely. The question is whether you fill it first.

SSH SOCKS5 Proxy in 2026: macOS, Linux, Windows & sshuttle: Complete Guide

Pooya Golchian — Tue, 07 Apr 2026 22:08:02 +0000

Two common scenarios require routing traffic through a remote server: accessing private network resources, or browsing from a different geographic IP. An SSH SOCKS5 tunnel solves both in under a minute, no VPN software required.

How SSH -D Works

The -D flag creates a dynamic port forward: SSH listens on a local port and acts as a SOCKS5 proxy. Traffic exits from the SSH server's network:

Your app -> localhost:1080 (SOCKS5) -> SSH encrypted -> remote server -> internet

macOS & Linux: Quick Start

# Start tunnel in background
ssh -D 1080 -f -C -q -N user@your-server.com

# Verify it is running
pgrep -a ssh

# Confirm traffic routes via the server
curl --socks5 127.0.0.1:1080 https://ipinfo.io/ip

Flag meanings:

-D 1080: SOCKS5 proxy on local port 1080
-f: fork to background after auth
-C: gzip compression
-q: quiet mode
-N: tunnel only, no remote command

macOS: Toggle Script

Save as ~/bin/tunnel, chmod +x, then sudo tunnel:

#!/usr/bin/env bash
NET_SERVICE="Wi-Fi"   # run: networksetup -listallnetworkservices
PORT=1080
SERVER="user@your-server.com"

if [[ "$EUID" -ne 0 ]]; then
  echo "Run as root: sudo $0"; exit 1
fi

PID=$(pgrep -f "ssh -D ${PORT}")

if [[ -n "$PID" ]]; then
  echo "Disconnecting (PID $PID)..."
  kill -9 "$PID"
  networksetup -setsocksfirewallproxystate "${NET_SERVICE}" off
  echo "Tunnel closed."
else
  echo "Connecting to ${SERVER}..."
  ssh -D "${PORT}" -f -C -q -N "${SERVER}"
  networksetup -setsocksfirewallproxy "${NET_SERVICE}" 127.0.0.1 "${PORT}"
  networksetup -setsocksfirewallproxystate "${NET_SERVICE}" on
  echo "Connected. System SOCKS proxy active on :${PORT}."
fi

networksetup sets the macOS system-wide SOCKS proxy, all apps that respect it route through the tunnel.

Linux: Route CLI Tools with Proxychains4

# Install
sudo apt install proxychains4         # Debian/Ubuntu
sudo dnf install proxychains-ng       # Fedora

# Edit /etc/proxychains4.conf:
#   comment out: socks4 127.0.0.1 9050
#   add:         socks5 127.0.0.1 1080

# Start the SSH tunnel
ssh -D 1080 -f -C -q -N user@your-server.com

# Route any CLI tool
proxychains4 curl https://ipinfo.io/ip
proxychains4 git clone https://github.com/someorg/private-repo

sshuttle: Transparent Full-System Proxy (No Config Required)

sshuttle routes all TCP traffic via OS-level interception:

brew install sshuttle           # macOS
sudo apt install sshuttle       # Ubuntu

# Route everything, exclude the SSH server to avoid a loop
sshuttle -r user@your-server.com 0.0.0.0/0 --exclude your-server.com

# Route only a private subnet behind the server
sshuttle -r user@your-server.com 10.0.0.0/8

# Stop with Ctrl+C

No browser config. Every TCP connection is intercepted transparently.

Windows: Bitvise + Proxifier

Install Bitvise SSH Client
Under Services > SOCKS/HTTP Proxy Forwarding, enable SOCKS5 on 127.0.0.1:1080. Log in.
Install Proxifier:
- Add proxy: 127.0.0.1:1080, SOCKS5
- Add rule targeting the apps you want to route (e.g., chrome.exe)

SSH Config for Reliability

Add to ~/.ssh/config to keep the tunnel alive through network idle timeouts:

Host tunnel-server
  HostName your-server.com
  User youruser
  IdentityFile ~/.ssh/id_ed25519
  ServerAliveInterval 60
  ServerAliveCountMax 3
  Compression yes

Start with: ssh -D 1080 -f -C -q -N tunnel-server

SSH -D vs sshuttle vs WireGuard

Feature	SSH -D	sshuttle	WireGuard
Setup complexity	Low	Low	Medium
Routes all traffic	No (per-app SOCKS)	Yes (all TCP)	Yes (all protocols)
UDP support	No	No	Yes
Server prerequisites	SSH only	SSH only	wireguard-tools
Speed	Good	Good	Excellent
Best for	Single-app routing	Full TCP proxy	Permanent VPN

Security Best Practices

Key-based auth only: ssh-keygen -t ed25519
Restrict server to your user: AllowUsers youruser in /etc/ssh/sshd_config
Use a non-standard port to reduce automated brute-force: Port 2222 in sshd_config
Rotate SSH keys annually

Software Developer Job Market Recovery: What the Data Shows in 2026

Pooya Golchian — Tue, 07 Apr 2026 22:07:46 +0000

Software developer job postings have increased 15% since mid-2025. After two years of layoffs, hiring freezes, and economic uncertainty, the tech job market is showing signs of recovery.

The data comes from the Federal Reserve Economic Data (FRED), which tracks job postings across industries. The trend line tells a story of resilience in the software development sector despite broader economic challenges FRED, 2026.

The 2024-2025 Tech Job Market Recession

To understand the recovery, we must first examine the downturn.

Layoff Numbers:

2024 saw over 260,000 tech workers laid off globally. Major companies including Google, Amazon, Meta, and Microsoft reduced headcounts by 5-15%. Startups faced extinction-level events as venture funding dried up.

Hiring Freeze Impact:

Job postings for software developers dropped 35% from peak levels in early 2024. Entry-level positions were hit hardest, with new graduate hiring down 60% at major tech companies.

Economic Factors:

Rising interest rates, inflation concerns, and geopolitical tensions created a perfect storm. Companies prioritized profitability over growth. Technical debt reduction replaced new feature development.

The Bottom:

The market reached its lowest point in Q2 2025. Developer job postings were 40% below 2023 levels. Unemployment in tech reached 3.2%, historically high for the sector.

Current Recovery Indicators

The 15% increase since mid-2025 signals genuine recovery, not just statistical noise.

Job Posting Volume:

Current levels are approaching 85% of 2023 peaks. While not fully recovered, the trajectory is positive. Month-over-month growth has been consistent for three consecutive quarters.

Sector Variations:

Not all tech sectors are recovering equally. Some industries are booming while others remain stagnant.

Geographic Distribution:

Remote job postings have increased disproportionately. Companies have accepted distributed teams as permanent fixtures. Traditional tech hubs (SF, Seattle, NYC) are recovering faster than secondary markets.

Salary Trends:

Compensation is stabilizing after 2024's downward pressure. Average software engineer salaries have increased 4% year-over-year. Senior roles command premiums again after a brief compression.

Which Sectors Are Hiring

The recovery is uneven across industry verticals.

AI/ML Engineering:

The clear winner. Job postings for AI/ML engineers are up 85% year-over-year. Companies are investing heavily in AI capabilities. Salaries for AI specialists have increased 20-30%.

Healthcare Technology:

Digital health continues growing. Electronic health records, telemedicine platforms, and health data analytics drive demand. Regulatory compliance requirements create specialized roles.

Financial Technology:

Fintech is rebounding strongly. Payment processing, blockchain applications, and automated trading systems require engineering talent. Traditional banks are competing with startups for developers.

Cybersecurity:

Security engineers remain in high demand. Breach headlines drive corporate investment. Zero-trust architecture implementations create sustained hiring needs.

E-commerce:

Online retail platforms are expanding engineering teams. Personalization engines, logistics optimization, and mobile commerce drive growth.

Struggling Sectors:

Social media platforms, ad-tech, and consumer apps remain cautious. Metaverse-related roles have declined 70% from 2023 hype peaks. Cryptocurrency companies have stabilized at much lower headcounts.

In-Demand Skills for 2026

The skills employers want have shifted during the recovery.

AI/ML Integration:

Not just building models, but integrating AI into existing products. Prompt engineering, LLM fine-tuning, and AI safety are emerging specializations.

Cloud Architecture:

Multi-cloud expertise is valued. Kubernetes, Terraform, and cloud-native development are table stakes. Cost optimization skills are particularly prized.

Full-Stack Development:

Versatility wins. Developers who can work across frontend, backend, and infrastructure are in demand. TypeScript, React, Node.js, and Python dominate job postings.

Data Engineering:

Building data pipelines, warehouses, and analytics platforms. Real-time processing and streaming architectures are growth areas.

Security Engineering:

Application security, secure coding practices, and compliance automation. DevSecOps integration is standard expectation.

Soft Skills:

Communication, business acumen, and adaptability are increasingly valued. Remote work requires self-management capabilities.

Entry-Level Market Conditions

New graduates face the most challenging conditions.

The Experience Paradox:

Employers want experienced developers but laid off junior staff disproportionately. Entry-level postings remain 45% below 2023 levels.

Alternative Pathways:

Bootcamps and alternative credentials are losing favor. Traditional computer science degrees are regaining prestige. Internship experience is critical.

Advice for New Developers:

Build public portfolios with real-world projects
Contribute to open source
Network aggressively through communities
Consider adjacent roles (QA, support, DevOps) as entry points
Be geographically flexible

Remote Work Normalization

The pandemic-era remote work experiment has become permanent policy.

Hybrid Models:

Most companies (68%) have settled on hybrid arrangements. Two to three days in office is standard. Fully remote roles are available but competitive.

Global Competition:

Remote work means competing globally. Developers in lower-cost regions compete for US salaries. Companies arbitrage geographic salary differences.

Collaboration Challenges:

Onboarding and mentorship suffer remotely. Junior developers report slower career progression. Companies are investing in virtual collaboration tools.

Salary Expectations in 2026

Compensation is recovering but remains below 2022 peaks.

United States:

Entry-level: $75,000 - $95,000
Mid-level: $110,000 - $150,000
Senior: $160,000 - $220,000
Staff/Principal: $250,000+

Europe:

Entry-level: €45,000 - €60,000
Mid-level: €65,000 - €85,000
Senior: €90,000 - €120,000

Remote/Global:

Salaries are trending toward regional averages rather than location premiums. US-based remote roles pay 15-20% less than SF/NYC office roles.

Equity Compensation:

Startup equity packages are less generous than 2021. Vesting schedules are longer. Liquidity events are rarer.

FAQ

Is the tech job market recovering?

Yes, software developer job postings are up 15% since mid-2025 according to Federal Reserve data. The recovery is uneven across sectors, with AI/ML roles leading growth while traditional software engineering is recovering more slowly FRED, 2026.

Which programming skills are most in demand?

AI/ML integration, cloud architecture (Kubernetes, Terraform), full-stack development (TypeScript, React, Node.js), data engineering, and security engineering are most sought-after. Python and JavaScript/TypeScript dominate job postings.

Are tech salaries increasing?

Average software engineer salaries have increased 4% year-over-year after stabilizing in 2024. AI/ML specialists see 20-30% increases. Senior roles command premiums again after brief compression.

Is remote work still available?

Yes, but the landscape has shifted. Fully remote roles are competitive. Most companies (68%) offer hybrid arrangements with 2-3 days in office. Remote work now means global competition for positions.

How hard is it to get an entry-level developer job?

Entry-level remains challenging with postings 45% below 2023 levels. Candidates need strong portfolios, internship experience, and networking. Alternative credentials have lost favor to traditional CS degrees.

What sectors are hiring most aggressively?

AI/ML engineering (up 85%), healthcare technology, fintech, cybersecurity, and e-commerce are hiring. Social media, ad-tech, and metaverse-related roles remain depressed.

Should I specialize or stay general?

Current market favors specialists in high-demand areas (AI/ML, security, data). However, full-stack versatility remains valuable for smaller companies. Consider T-shaped skills: deep expertise in one area with broad general knowledge.

Conclusion

The software developer job market is recovering, but it is not the same market as 2022. The AI boom has created new specializations. Remote work has globalized competition. Economic caution has made efficiency a priority.

For developers, the message is clear: adapt to AI integration, build demonstrable expertise, and remain flexible about work arrangements. The days of easy job hopping and inflated salaries are over. The new market rewards skill, specialization, and business acumen.

The 15% increase in job postings is a leading indicator. Hiring precedes economic confidence by several months. If the trend continues, 2026 could mark the return of a healthy, sustainable tech job market.

The industry has matured. So must the developers who power it.

Pooya Golchian is an AI Engineer and Full Stack Developer analyzing technology trends and career development. Follow him on Twitter @pooyagolchian for more insights on the tech industry.

Self-Hosting AI in 2026: 55% TCO Reduction, 18ms Latency, and the Open Source Stack That Replaces Cloud APIs

Pooya Golchian — Tue, 07 Apr 2026 22:07:31 +0000

70-90% of AI operational costs come from inference, not training. Stanford's 2023 AI Index Report quantified what practitioners already knew: running models in production costs more than developing them. Cloud GPU instances at $32/hour compound into six-figure annual bills. API pricing per token scales linearly with usage and never gets cheaper at volume.

Self-hosting flips that cost structure. You pay once for hardware. You optimize continuously on your own infrastructure. IDC data from 2024 confirms a 55% total cost of ownership reduction after 18 months for organizations running 10B+ parameter models.

This article covers the cost math, the hardware benchmarks, and the open source tool stack that makes self-hosted AI infrastructure viable for organizations of every size.

The Cost Case

Cloud AI costs hit organizations in three layers: infrastructure, inference, and engineering. The total picture matters more than any single line item.

Cloud infrastructure runs $420K over 18 months for a mid-scale deployment on AWS or GCP. That covers GPU instances (p4d.24xlarge at $32/hour), storage, networking, and load balancing. Inference costs add another $380K in API calls to OpenAI, Anthropic, or Google. Engineering overhead sits at $60K for integration and monitoring.

Self-hosted infrastructure inverts the ratio. Hardware costs $180K upfront for a GPU cluster (4x H100, networking, storage). Inference drops to $45K because you own the GPUs. Engineering costs rise to $120K because you maintain the stack yourself. Total: $345K versus $860K.

The 55% TCO reduction materializes after month 12-18 when the hardware investment amortizes against ongoing cloud costs. Before that break-even point, cloud remains cheaper for sporadic workloads that do not justify dedicated hardware.

Latency: 19x Faster Than Cloud APIs

Self-hosted H100 inference hits 18ms average latency. Cloud API endpoints from OpenAI and Anthropic average 350ms. Cloud GPU instances on AWS sit at 180ms. Self-hosted A100 delivers 45ms.

The 19x latency improvement between self-hosted H100 and cloud APIs comes from eliminating network round trips, load balancer hops, and shared tenant scheduling. Your request goes directly from your application to your GPU with zero intermediaries.

Goldman Sachs reported 40% latency reduction after moving inference in-house for risk modeling. Real-time trading systems require sub-100ms response times that cloud APIs cannot guarantee. Medical diagnostics systems at institutions like Mayo Clinic deployed on-premises AI clusters for the same reason.

For applications where latency tolerance exceeds 500ms (batch processing, offline analysis, non-interactive summarization), cloud APIs remain perfectly adequate. The self-hosting advantage concentrates in real-time, interactive, and high-throughput use cases.

GPU Hardware ROI Timeline

The break-even calculation determines whether self-hosting makes financial sense for a specific workload.

NVIDIA H100 GPUs cost $30,000-$40,000 per unit. A production-ready cluster with 4 GPUs, networking, storage, and a host server runs $160,000 upfront. Monthly operational costs (power, cooling, maintenance, engineering time) add $10,000.

Cloud GPU instances (AWS p4d.24xlarge) cost $23,000/month at continuous utilization. No upfront investment, but costs accumulate linearly.

The crossover happens at month 9. By month 24, the self-hosted cluster saves $280K in cumulative costs compared to cloud. The gap widens with every additional month because cloud costs continue while self-hosted hardware costs are already paid.

Organizations with intermittent GPU needs (less than 30% utilization) should stay on cloud. Self-hosting pays off when utilization exceeds 50% sustained.

Why Organizations Self-Host

Five drivers push enterprises away from cloud AI services. Data privacy leads.

67% of EU enterprises cite data residency as a critical barrier to cloud AI adoption (Gartner 2023). GDPR requires that personal data processing stays within jurisdictional boundaries. HIPAA mandates specific controls for protected health information. Financial regulations impose data handling requirements that cloud AI APIs cannot satisfy without complex data processing agreements.

Cost control follows at 55%. Organizations running large models at scale watch their cloud inference bills grow linearly with usage. Cloud pricing never rewards volume. Self-hosted inference costs decline asymptotically as hardware amortizes.

45% of enterprises prioritize open source stacks specifically to avoid vendor lock-in (Linux Foundation 2024). Cloud AI services impose rate limits, proprietary output formats, and egress fees that create switching costs. Self-hosted infrastructure with open source models eliminates all three.

Latency requirements drive 40% of self-hosting decisions. Customization needs, including fine-tuning, quantization, and custom batching strategies, motivate the remaining 38%.

The Open Source Tool Stack

Five tools form the production self-hosting stack.

vLLM is the default inference engine. Released by UC Berkeley in 2023, it achieves 2-4x throughput over Hugging Face Transformers through PagedAttention, a memory management technique that eliminates redundant KV-cache allocation. LinkedIn and Uber run vLLM in production. Apache 2.0 license. Supports NVIDIA GPUs with experimental AMD support.

Text Generation Inference (TGI) from Hugging Face offers 1.5-3x throughput gains. It powers Hugging Face Inference Endpoints and supports Intel Gaudi accelerators alongside NVIDIA. The Flash Attention 2 integration reduces memory footprint for long-context generation.

Triton Inference Server from NVIDIA adds model serving with dynamic batching, model ensembling, and multi-model management. It pushes 3-5x throughput over naive serving through request queuing and GPU scheduling optimization.

Kubernetes with NVIDIA GPU Operator handles orchestration. The GPU Operator automates driver installation, device plugin configuration, and monitoring setup. JPMorgan Chase and Goldman Sachs run AI workloads on Kubernetes clusters with this stack.

Docker containers package models and their dependencies into reproducible deployments. A Dockerfile with vLLM, a quantized model, and an API wrapper gives you a single deployable artifact.

GPU Performance Benchmarks

The hardware choice determines throughput, cost per token, and model compatibility.

NVIDIA H100 (80GB HBM3) delivers 580 tokens/second on LLaMA 70B inference at $0.18 per 1M tokens. It represents the price-performance sweet spot for production workloads.

The H200 (141GB HBM3e) pushes 720 tokens/second with enough memory to run 70B parameter models without tensor parallelism across multiple GPUs. That simplifies deployment and reduces inter-GPU communication overhead.

A100 (80GB HBM2e) remains viable at 180 tokens/second and $0.42 per 1M tokens. Used H100 pricing will push A100s into budget-tier territory through 2026-2027.

L40S (48GB GDDR6) targets inference workloads that do not require HBM. At 120 tokens/second, it handles smaller models (7B-13B) efficiently and costs significantly less than the HBM-equipped options.

MLPerf Inference v4.0 benchmarks confirm H100 delivers 3.2x the throughput of A100 for GPT-J inference. The H200 extends that gap further.

Getting Started

A minimal self-hosted stack for local development and evaluation:

# Install vLLM
pip install vllm

# Start an OpenAI-compatible API server with a quantized model
python -m vllm.entrypoints.openai.api_server \
    --model TheBloke/Llama-2-70B-Chat-GPTQ \
    --quantization gptq \
    --tensor-parallel-size 4 \
    --port 8000

# Query the model
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "TheBloke/Llama-2-70B-Chat-GPTQ",
        "messages": [{"role": "user", "content": "Explain vLLM PagedAttention"}],
        "max_tokens": 512
    }'

For Kubernetes production deployments:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-inference
spec:
  replicas: 2
  selector:
    matchLabels:
      app: vllm
  template:
    metadata:
      labels:
        app: vllm
    spec:
      containers:
        - name: vllm
          image: vllm/vllm-openai:latest
          args:
            - "--model"
            - "meta-llama/Llama-2-70b-chat-hf"
            - "--tensor-parallel-size"
            - "4"
          resources:
            limits:
              nvidia.com/gpu: 4
          ports:
            - containerPort: 8000
      nodeSelector:
        nvidia.com/gpu.product: "NVIDIA-H100-80GB-HBM3"

Scale horizontally behind a load balancer. Add Prometheus metrics for latency, throughput, and GPU utilization monitoring. Set alerts at p99 latency above 100ms and GPU utilization below 40% (indicates over-provisioning).

Self-hosting data sourced from IDC AI Infrastructure Report 2024, Stanford AI Index 2023, Gartner Cloud AI Survey 2023, MLPerf Inference v4.0 benchmarks, Linux Foundation Open Infrastructure Survey 2024, and NVIDIA DGX documentation.

Subscribe to get new research articles with data visualizations

scss-helper v5: A Modern SCSS Utility Toolkit for Tailwind's Gaps

Pooya Golchian — Tue, 07 Apr 2026 22:07:15 +0000

Tailwind CSS handles most styling needs well, but it doesn't cover everything. Fluid typography, CSS container queries, golden ratio layouts, and full 12-column grid control fall outside its scope. I built scss-helper to fill exactly those gaps, a modular toolkit that complements Tailwind without competing with it.

Full Documentation

What's Included

30+ CSS custom property tokens: colors, spacing, typography
12-column CSS grid with responsive breakpoints and auto-fit layouts
Fluid clamp() typography: continuous scaling, no breakpoints needed
Dark mode: dual strategy: data-theme attribute + prefers-color-scheme
CSS container queries for component-level responsiveness
Golden ratio typography, spacing, and grid layouts (φ = 1.618)
12 animations + 5 transition presets, all prefers-reduced-motion aware
Tailwind CSS v3/v4 plugin to use tokens alongside Tailwind

All classes use the sh- prefix (configurable). Full bundle is 5.1 KB gzipped.

Installation

pnpm add scss-helper
pnpm add -D sass  # Dart Sass >= 1.60 required

Quick Start

SCSS (recommended)

@use 'scss-helper';

// Or cherry-pick modules
@use 'scss-helper/src/tokens/index';
@use 'scss-helper/src/typography/fluid';
@use 'scss-helper/src/golden/golden-ratio';

Pre-compiled CSS

@import 'scss-helper/css';          /* Full bundle, 5.1 KB gzipped */
@import 'scss-helper/css/grid';     /* Grid only, 1.7 KB gzipped */
@import 'scss-helper/css/tokens';   /* Tokens only, 583 B gzipped */

CDN

<link rel="stylesheet" href="https://unpkg.com/scss-helper@5/dist/style.css">

Design Tokens

:root {
  --color-primary: #0d6efd;
  --spacing-1: 0.25rem;
  --spacing-4: 1rem;
  --font-size-base: 1rem;
  --line-height-base: 1.5;
}

30+ CSS custom properties generated from Sass variables. Compatible with Tailwind v4 @theme.

CSS Grid System

<!-- Basic 12-column grid -->
<div class="sh-grid sh-gap-4">
  <div class="sh-col-8">Main</div>
  <div class="sh-col-4">Sidebar</div>
</div>

<!-- Responsive, stacks on mobile, splits on desktop -->
<div class="sh-grid sh-gap-4">
  <div class="sh-col-12 sh-col-6-md sh-col-4-lg">Card</div>
  <div class="sh-col-12 sh-col-6-md sh-col-4-lg">Card</div>
  <div class="sh-col-12 sh-col-12-md sh-col-4-lg">Card</div>
</div>

<!-- Auto-fit: fills available space -->
<div class="sh-grid-auto-md sh-gap-4">
  <div>Card</div>
  <div>Card</div>
  <div>Card</div>
</div>

Breakpoint suffixes: -xs (32rem) · -sm (48rem) · -md (64rem) · -lg (80rem) · -xl (90rem)

Fluid Typography

Continuous font scaling using CSS clamp(), no media queries:

<h1 class="sh-text-fluid-4xl">Headline</h1>
<p class="sh-text-fluid-base">Body text</p>

Class	Scale
`sh-text-fluid-xs`	12px → 14px
`sh-text-fluid-sm`	14px → 16px
`sh-text-fluid-base`	16px → 18px
`sh-text-fluid-lg`	18px → 22px
`sh-text-fluid-xl`	20px → 28px
`sh-text-fluid-2xl`	24px → 36px
`sh-text-fluid-3xl`	30px → 48px
`sh-text-fluid-4xl`	36px → 64px

Or call the SCSS function for arbitrary ranges:

@use 'scss-helper/src/typography/fluid' as fluid;

h1 { font-size: fluid.fluid-type(1.5rem, 3rem); }
h2 { font-size: fluid.fluid-type(1rem, 2rem, 30rem, 90rem); }

Golden Ratio Layouts

A full design system derived from phi (1.618):

<h1 class="gs-text-3">Display, 4.236rem</h1>
<h2 class="gs-text-2">Section, 2.618rem</h2>
<p  class="gs-text-0">Body, 1rem</p>

<!-- 61.8% / 38.2% layout -->
<div class="gs-grid-golden">
  <main>Content</main>
  <aside>Sidebar</aside>
</div>

@use 'scss-helper/src/golden/golden-ratio' as golden;

h1 {
  font-size: golden.golden-step(2);      // 2.618rem
  margin-bottom: golden.golden-step(1);  // 1.618rem
}

Dark Mode

Dual strategy, works with JS toggles and prefers-color-scheme simultaneously:

<p class="sh-dark-text-white">White in dark mode</p>

@use 'scss-helper/src/dark/dark-mode' as dark;

.card {
  background: white;
  @include dark.dark-mode {
    background: #1a1a1a;
    color: white;
  }
}

document.documentElement.dataset.theme =
  document.documentElement.dataset.theme === 'dark' ? 'light' : 'dark';

Container Queries

<div class="sh-cq">
  <div class="sh-c-col-12 sh-c-col-6-sm sh-c-col-4-md">
    Responds to container width, not viewport
  </div>
</div>

Animations

<div class="sh-animate-fade-in">Fades in</div>
<div class="sh-animate-slide-up sh-delay-200">Slides up after 200ms</div>
<button class="sh-transition-colors sh-duration-fast">Smooth color</button>

All 12 animation classes respect prefers-reduced-motion.

Tailwind CSS Plugin

const scssHelper = require('scss-helper/plugin');
module.exports = { plugins: [scssHelper({ injectTokens: true })] };

Customization

@use 'scss-helper' with ($prefix: 'my-');
// -> .my-grid, .my-col-6, .my-animate-spin

@use 'scss-helper/src/variables' with (
  $primary: #8b5cf6,
  $grid-columns: 16,
);
@use 'scss-helper';

v5 Migration from v4

v4	v5
`.grid`	`.sh-grid`
`.col-6`	`.sh-col-6`
`.text-fluid-lg`	`.sh-text-fluid-lg`
`.animate-spin`	`.sh-animate-spin`
`.transition-colors`	`.sh-transition-colors`
`@import "scss-helper"`	`@use "scss-helper"`
`-large` suffix	`-lg` suffix

GitHub · npm · Full Documentation

Forem: Pooya Golchian

WhatsApp and Telegram Automation in Dubai: AI-Powered Bots for Business

WhatsApp and Telegram Automation in Dubai

Why Messaging Automation Matters for Dubai Businesses

What Gets Built

Use Cases That Drive Revenue

Technology Stack

Start Automating

vue-star-rate: Zero-Dependency Vue 3.5+ Star Rating Component

Installation

Basic Usage

Half-Star Ratings

Size Presets

Custom Colors

Icon Providers

Read-Only Mode

Keyboard Navigation

Tooltips and Counters

Full Configuration Example

Props Reference

Programmatic Control

Migration from v2

vue-multiple-themes v4: Dynamic Multi-Theme Support for Vue 2 & 3

What It Solves

Installation

Quick Start: Vue 3

CSS Custom Properties

The 7 Preset Themes

Dynamic Theme Generation

TailwindCSS Integration

WCAG Utilities

useTheme() API

Vue 2 Support

Vibe Coding in 2026: $9.2B Cursor, 92% HumanEval, and the End of Boilerplate

The Market Numbers

Platform Landscape and Valuations

Pricing Breakdown

AI Model Benchmarks

Productivity Impact

Enterprise Adoption Trajectory

What Changes Next

use-local-llm: React Hooks for AI That Actually Work Locally

Why Existing Tools Don't Fit

How It Works

One Hook. That's It.

Works With Any Local LLM

Advanced: Token-by-Token Control

Discover Available Models

How It Compares

Why It's Built This Way

Zero Dependencies (2.8 KB Total)

Works Outside React Too

AbortController Integration

Full TypeScript Support

Architecture

When to Reach for use-local-llm

Start Building

TypeScript 6.0: New Features Every Developer Should Know

Performance Improvements: Faster Compilation

Enhanced Type Inference

New Language Features

Developer Experience Enhancements

Breaking Changes and Deprecations

Migration Guide: Upgrading to TypeScript 6.0

Ecosystem Impact

Comparison with Alternative Typed Languages

FAQ

Conclusion

Supply Chain Attacks on Developers: Lessons from LiteLLM and Trivy

The LiteLLM PyPI Compromise

The Trivy GitHub Actions Compromise

How Supply Chain Attacks Work

Protecting Your Projects

Industry Response and Best Practices

The Economic Impact

FAQ

Conclusion

State of the Product Job Market in Early 2026

The PM Numbers

Engineering's Comeback

`useTheme()` API