2026-03-01 09:00:00
I’ve seen it happen too many times:
A brilliant dev team spends 3 months building a perfect scalable architecture for a problem the business hasn't even validated yet.
The result? A technical masterpiece that nobody uses.
In the startup world, code is a liability until it’s solving a business problem. Here’s why your software should follow your business - not the other way around.
Your customers don't care if you're using Clean Architecture or a messy monolith. They care if the button works and solves their pain. If the business pivots (which it will), your code needs to be flexible enough to follow - not so rigid that it blocks the move.
We often build for 1 million users when we only have 10. That’s "Software leading the Business." Instead, build for the business reality of today.
It’s better to have a successful business with "messy" code than a failed startup with "perfect" code.
A Senior Developer’s job isn't just writing functions; it’s understanding the Business Model. If you don't know how your company makes money, you can't write effective software for it.
Stop asking 'How can we build this?' and start asking 'Should we build this?' Let the business goals drive the git commits.
Originally shared in a more casual, local context (Malay) on my blog: Read the original here. I'm curious — have you ever worked at a place where the tech dictated the business? Let's discuss below!
2026-03-01 09:00:00
Privacy is not just a feature; it’s a human right—especially when it comes to your health data. In the era of Local AI and Edge Computing, sending sensitive Electronic Health Records (EHR) to a cloud provider is becoming a gamble many aren't willing to take. If you are a developer looking to leverage the power of Llama-3 while ensuring 100% data sovereignty, you've come to the right place. 🚀
In this tutorial, we are going to build a Local-First Health AI using the MLX framework on Apple Silicon. We’ll transform raw, messy medical notes into structured data and concise summaries without a single byte leaving your MacBook. By the end of this guide, you’ll understand how to optimize Llama-3 for Mac hardware to achieve lightning-fast inference for Privacy-first healthcare applications.
Apple's MLX is a NumPy-like array framework designed specifically for machine learning on Apple Silicon. Unlike generic frameworks, MLX utilizes the Unified Memory Architecture of M1/M2/M3 chips, allowing the GPU and CPU to share data seamlessly. This is a game-changer for processing large language models (LLMs) locally.
Here is how we handle sensitive medical data without ever touching the internet:
graph TD
A[Raw Medical Record / PDF] -->|Local Script| B(Python Pre-processing)
B --> C{MLX Engine}
C -->|Unified Memory| D[Llama-3-8B-Instruct]
D --> E[Summarization & Entity Extraction]
E -->|JSON Output| F[Local Health Dashboard]
subgraph Privacy Boundary (Your MacBook)
B
C
D
E
end
To follow along, you’ll need:
mlx-lm library (the high-level API for running LLMs on MLX).
pip install mlx-lm huggingface_hub
Instead of using the heavy raw weights, we will use a 4-bit quantized version of Llama-3. This reduces memory pressure significantly while maintaining impressive medical reasoning capabilities.
from mlx_lm import load, generate
# Load the Llama-3 8B model optimized for MLX
model_path = "mlx-community/Meta-Llama-3-8B-Instruct-4bit"
model, tokenizer = load(model_path)
print("✅ Model loaded successfully on Apple Silicon!")
Medical records are often unstructured. We need a robust prompt to extract "Symptoms," "Diagnoses," and "Medications."
def process_health_record(raw_text):
prompt = f"""
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
You are a professional medical assistant. Analyze the following medical record.
Extract the key information in JSON format:
- Summary (1 sentence)
- Primary Diagnosis
- Prescribed Medications
- Follow-up actions
Do not include any cloud-based references.
<|eot_id|><|start_header_id|>user<|end_header_id|>
Record: {raw_text}
<|eot_id|><|start_header_id|>assistant<|end_header_id|>
"""
response = generate(model, tokenizer, prompt=prompt, verbose=False, max_tokens=500)
return response
# Example Usage
raw_ehr = "Patient presents with persistent cough for 2 weeks. BP 140/90. Prescribed Amoxicillin 500mg. Return in 7 days."
result = process_health_record(raw_ehr)
print(result)
Running Llama-3 locally on an M3 Max can yield upwards of 50-70 tokens per second. Even on a base M1 MacBook Air, you can expect a very usable 15-20 tokens per second. Because MLX uses the Metal Performance Shaders (MPS), the energy efficiency is significantly better than running it via traditional CPU-bound methods.
While running a script on your laptop is great for personal use, scaling local AI for healthcare organizations requires more robust patterns—including encrypted storage, HIPAA-compliant local pipelines, and advanced quantization techniques.
For more production-ready examples and advanced patterns on deploying privacy-centric models, I highly recommend checking out the WellAlly Technical Blog. They provide deep dives into how modern AI can be reconciled with strict data privacy laws.
We just turned a standard MacBook into a powerful, private medical assistant. By leveraging MLX and Llama-3, we’ve proved that you don't need a massive server farm (or a massive privacy risk) to process complex health data.
Key Takeaways:
What are you building locally? Let me know in the comments below! If you found this helpful, don't forget to ❤️ and 🦄.
2026-03-01 08:41:25
Hey folks! 👋
I've been working on PulseWatch — an AI-powered website monitoring tool that tracks changes on any webpage and sends instant notifications. I wanted to share how I built it and what makes it different from existing solutions.
We all need to track changes on websites sometimes — price drops on Amazon, new job postings, API documentation updates, stock availability, or news articles. The existing tools either require complex CSS selectors or are too expensive for what they offer.
PulseWatch uses GPT-4o to analyze web pages and suggest what to monitor. Instead of writing CSS selectors manually, you can:
Here's what powers PulseWatch under the hood:
The monitoring flow is straightforward:
The AI summary is a game-changer — instead of just saying "something changed," PulseWatch tells you what changed in plain language.
One of the most requested features was flexible notifications. PulseWatch supports:
As a developer, I wanted PulseWatch to be API-first. The REST API lets you:
GET /api/watches — List all monitors
POST /api/watches — Create a new monitor
GET /api/watches/:id — Get monitor details
DELETE /api/watches/:id — Delete a monitor
GET /api/history/:id — Get change history
Authenticate with an API key (X-API-Key header) and build your own integrations. Full docs at pulsewatch.watch/docs/api.
I also built a Chrome extension that lets you add any website to PulseWatch directly from your browser. Right-click on any page → "Monitor with PulseWatch" → done.
Available on the Chrome Web Store.
PulseWatch supports 9 languages: English, Turkish, German, Spanish, French, Arabic, Japanese, Korean, and Chinese. The landing page, app, and even AI-generated change summaries are all localized.
I'm currently working on:
PulseWatch has a free tier (2 monitors, daily checks) so you can try it without commitment. Paid plans start at $8.99/month for more monitors, faster checks, and API access.
🔗 Website: pulsewatch.watch
📱 Chrome Extension: Chrome Web Store
📖 API Docs: pulsewatch.watch/docs/api
I'd love to hear your feedback! What features would you find most useful? Drop a comment below 👇
2026-03-01 08:41:12
This is a submission for the Built with Google Gemini: Writing Challenge
I built Construct Note, a fast, local-first Kanban and task management desktop application.
Many modern productivity apps rely heavily on cloud syncing and subscriptions, which can be a privacy concern for users who want complete control over their own data. I wanted to build a Trello-like application that lives entirely on the user's machine, offering the same rich drag-and-drop experience without the data leaving the local file system.
The Tech Stack:
@hello-pangea/dnd for fluid drag-and-drop mechanics.better-sqlite3 for high-performance, synchronous database operations.Key Features:
react-markdown).constructnote.db) operating in WAL (Write-Ahead Log) mode for speed.What role did Google Gemini play?
I used Google Gemini as my AI pair-programmer throughout the majority of the development lifecycle. Gemini helped me:
better-sqlite3 for Linux, Gemini helped debug the build process and correctly configure the asarUnpack bindings..asar archive, and how to configure electron-builder to correctly rebuild them for specific target platforms.What worked well?
Gemini was surprisingly good at holding context of my project. I did not have to repeat myself too many times and I was able to actually progress much quicker in certain areas by having something to bounce ideas off rather than spending hours reading documentation and trying to figure out edge cases.
2026-03-01 08:36:41
As developers, we commit code constantly. The annoying part is that quick commits tend to force a slow workflow:
git add . && git commit -m "fix" in a terminal and hope you remember what changed.I wanted the best parts of both worlds: visual staging like a GUI, but the speed of a terminal.
So I built GitPop: a lightweight Windows File Explorer extension that adds a modern Git commit UI to your right-click menu, with an optional local AI commit generator.
From File Explorer, you can right-click inside any repo folder and choose GitPop Here to open a small popup that lets you:
The core goal is simple: make the “small commit” workflow as fast as a shell command, but less blind.
For a context menu popup, the most important metric is startup time. If right-clicking a folder and selecting GitPop Here takes a noticeable moment, it feels broken.
GitPop uses:
I ruled out Electron because it ships a full Chromium runtime and commonly incurs large binary sizes and heavier memory overhead compared to a native-webview approach. Tauri uses the system webview (WebView2 on Windows) with a Rust backend, which fits the “open instantly” requirement much better.
Windows integration looks simple from the outside, but there are a few spicy corners. These were the big three.
To show GitPop Here in the right-click menu, GitPop needs to register a command in the Windows Registry.
Instead of asking users to run a .reg file (which feels sketchy even when it is not), GitPop can do this via a Rust command in a “Setup Mode”.
This uses the winreg crate and registers under:
HKCU\Software\Classes\Directory\Background\shell\GitPopThat keeps the install per-user (no admin required) and binds the command to the app executable path:
use winreg::enums::*;
use winreg::RegKey;
#[tauri::command]
fn install_context_menu() -> Result<(), String> {
let hkcu = RegKey::predef(HKEY_CURRENT_USER);
let exe_path = std::env::current_exe()
.map_err(|e| e.to_string())?
.to_string_lossy()
.into_owned();
let bg_path = r#"Software\Classes\Directory\Background\shell\GitPop"#;
let (bg_key, _) = hkcu
.create_subkey(bg_path)
.map_err(|e| e.to_string())?;
bg_key.set_value("", &"GitPop Here").map_err(|e| e.to_string())?;
bg_key
.set_value("Icon", &format!("\"{}\"", exe_path))
.map_err(|e| e.to_string())?;
let (bg_cmd, _) = bg_key
.create_subkey("command")
.map_err(|e| e.to_string())?;
// %V resolves to the clicked folder path for Directory\Background handlers.
bg_cmd
.set_value("", &format!("\"{}\" \"%V\"", exe_path))
.map_err(|e| e.to_string())?;
Ok(())
}
Why this approach works well:
GitPop does not use libgit2. Instead, the Rust backend spawns native Git CLI commands like:
git status --porcelaingit diff --cachedgit commit -m ...This is intentional: the Git CLI automatically respects the user’s existing SSH keys, credential helpers, hooks, and global configs.
On Windows, though, naïvely calling Command::new("git") can cause a CMD window to flash briefly. It is the kind of micro-annoyance that makes an app feel janky.
The fix is to set a Windows-specific process creation flag so child processes run hidden:
use std::process::Command;
#[cfg(target_os = "windows")]
use std::os::windows::process::CommandExt;
#[cfg(target_os = "windows")]
const CREATE_NO_WINDOW: u32 = 0x08000000;
fn build_hidden_cmd(program: &str) -> Command {
let mut cmd = Command::new(program);
#[cfg(target_os = "windows")]
{
cmd.creation_flags(CREATE_NO_WINDOW);
}
cmd
}
From there, all Git calls use build_hidden_cmd("git") instead of Command::new("git").
I wanted a transparent, glassy popup. That means:
"transparent": true"visible": false
window.show())The catch is that Tauri v2 locks down frontend APIs by default. Without the right capability permissions, the window did not crash, it just stayed invisible while the process happily ran in the background.
The fix is to explicitly allow the window operations your frontend performs in capabilities/default.json:
{
"permissions": [
"core:window:default",
"core:window:allow-show",
"core:window:allow-close",
"process:allow-exit"
]
}
This is one of those “security first” defaults that is correct, but it will absolutely prank you the first time you try to do anything window-related.
Writing commit messages is small, but it adds friction. GitPop’s ✨ Sparkle button reduces that friction:
git diff --cached
Privacy matters. Shipping proprietary diffs to a cloud API is a non-starter for a lot of dev work. So GitPop defaults to Ollama, running locally. It detects installed models (for example llama3.2 or qwen2.5-coder) and generates commit messages without API keys, paid tokens, or network calls.
GitPop also supports OpenAI, Anthropic, Gemini, and custom endpoints for people who prefer hosted models. The model selection is an implementation detail. The UX goal is consistent: stage, sparkle, commit, done.
If you are on Windows (Soon OSx) and this fits your workflow, grab the latest installer from the repository:
Feedback, issues, and PRs are welcome. I am also exploring what it would take to bring the same “right-click commit UI” to macOS Finder, where the integration constraints are different but the pain is identical.
Happy committing.
2026-03-01 08:36:32
This is a submission for the Built with Google Gemini: Writing Challenge
A few months ago I entered DEV's New Year, New You Portfolio Challenge and decided to rebuild my portfolio from scratch. The brief: use Google AI's tools, deploy to Cloud Run, make it yours.
The result is "Brutalist/Industrial" (original submission post). The aesthetic intentionally rejects the clean, white-space-heavy look that most developer portfolios default to. Exposed grids, heavy typography with the SCHABO typeface, cursor-reactive background cells, a mathematically generated DNA helix that assembles and deconstructs as you scroll. The whole thing runs on Astro with React islands, GSAP for animations, and OGL (a lightweight WebGL library) for a metaballs footer effect.
The most interesting part, at least for this challenge, was the Gemini integration I shipped as actual product features rather than just development tooling:
Pitch Generator: paste any job description into it, and it pulls from a structured knowledge base of my work to generate a tailored pitch explaining why I'm a fit. Not a boilerplate cover letter, a specific one.
Interactive Assistant: a terminal-style interface that answers questions about my stack and recommends relevant projects based on what the visitor is looking for. It uses RAG with my portfolio data as the knowledge base, served through Google Genkit with Zod-validated flows and server-side rendering via Astro's Node adapter.
Both features run on Gemini 2.5 Flash. I wanted to demonstrate that AI in a portfolio doesn't have to mean a chatbot that says "Hi! I'm Ore's assistant." It can be a tool that does something useful for the person looking at your work.
I also used Google Antigravity as my primary AI coding pair throughout the build, and Nano Banana Pro to generate and iterate on imagery to match the industrial art direction.
Google Antigravity handled things I would have spent hours on otherwise: refactoring the original Codegrid template (raw HTML/CSS/JS with a sci-fi theme) into Astro and React components, writing the sine wave math for the DNA helix, catching performance regressions in the WebGL loop.
On the engineering side, it was often genuinely good. Give it a clear, bounded problem ("make this GSAP ScrollTrigger reversible on scroll-up") and it would produce something workable on the first or second attempt.
The design side was a different story, and this was the biggest surprise.
What I didn't anticipate was how little the AI could help with actual creative direction. I had a clear concept (Industrial/Brutalist, raw, engineering-first) but when I tried to use it to develop the visual language, I kept getting suggestions that were technically fine and aesthetically inert. Gradient proposals that belonged on a SaaS landing page. Color palettes that were "safe." Layout ideas that could have come from any template.
The AI wasn't wrong. It just had no sense of what I was going for, and no amount of prompting about "brutalism" or "industrial aesthetic" closed that gap. I ended up doing all the design decision-making myself and using the AI to execute those decisions, not to arrive at them.
The real skill I walked away with is knowing which problems to hand off and which to hold. Bounded, well-specified engineering problems: hand off. Open-ended creative decisions that require taste: hold.
My biggest gripe isn't dramatic. No hallucinated APIs, no rate limit crises. The problem was subtler: outputs were consistently competent and consistently generic until I provided so much direction that I might as well have specified the answer in the prompt.
For the Pitch Generator, early iterations produced pitches that were accurate but read like they were assembled from a template. "Ore is a skilled full-stack engineer with experience in X, Y, and Z..." Fine. Forgettable. I spent a lot of time refining the system prompt and knowledge base schema to push the outputs toward something that actually sounded like how I'd pitch myself in a real conversation.
What worked well was the Genkit integration. The type-safe flows with Zod schemas made it straightforward to build production-ready AI features without treating the model as a black box. Server-side rendering through Astro's Node adapter kept API keys secure without any awkward workarounds. That part of the experience was genuinely smooth.
The lesson on the friction side: Gemini rewards precision. Vague prompts produce vague results. When I described exactly what I wanted (the tone, the structure, specific things to emphasize) the quality went up meaningfully. But that precision requires you to already know what good looks like, which means the model can't substitute for taste, only for execution once the taste is established.
The portfolio is staying live and I plan to keep building on the AI features. The Pitch Generator currently takes a job description and outputs a pitch; I want to add a follow-up mode where the visitor can ask it to emphasize particular aspects of my background, making it more of a back-and-forth tool than a one-shot output.
The Interactive Assistant's knowledge base is static right now, a JSON structure I maintain manually. I want to connect it to a proper database so I can update it as I ship new projects without redeploying.
I'm also looking at adding project search using embeddings instead of keyword matching, so someone can describe what they're trying to build and get back relevant work from my portfolio rather than having to browse everything.
The DNA helix math, the Genkit integration, the Cloud Run deployment pipeline: all of it benefited from AI assistance. The decision to build an industrial portfolio that looks nothing like other portfolios? That one was mine.