Ali Raza

Harness engineering: the layer everyone’s building and nobody’s naming

2026-04-18T00:00:00+00:00

Every serious AI coding setup has a hidden layer underneath the model. It’s not the model. It’s not the IDE plugin. It’s the infrastructure that decides what the model knows when it starts, what it remembers while it works, and what survives after it stops.

I’ve been calling this harness engineering. Nobody else seems to be using that term, but the problem is real and every team building with AI is solving it — mostly in silence, mostly from scratch.

What the problem actually is

LLMs are stateless. Every session starts cold. The model has no memory of the deploy that broke prod last Tuesday, no recollection of the architectural decision you spent three hours debating, no awareness that you’ve already rejected this particular approach twice before.

You end up re-explaining your stack. Re-establishing constraints. Watching the model repeat mistakes you’ve already corrected. The cost isn’t just time — it’s trust. You stop relying on the model for anything that requires context, which is most of what matters.

A harness is the infrastructure layer that fixes this. At minimum it answers three questions:

What does the model know at the start of a session?
What gets recorded while the model works?
What survives when the session ends?

The answers vary wildly depending on which system you’re using.

How the main systems answer these questions

Claude Code

Claude Code has CLAUDE.md — a markdown file that gets injected into context at session start. You write it manually. It’s useful but static: it knows what you told it, not what it observed.

More recently (v2.1.59+), Anthropic added Auto-Memory: a background system that watches your sessions, extracts insights, and saves structured summaries to disk automatically. It’s early, but it’s the right direction.

The gap: CLAUDE.md doesn’t update itself. Auto-Memory helps but isn’t yet a full episodic layer. There’s no built-in mechanism for the model to review what it learned last week and decide what’s worth keeping permanently.

What survives a session: Whatever you manually put in CLAUDE.md, plus Auto-Memory summaries if enabled. No automatic learning.

OpenAI Codex CLI

Codex has persistent memory in preview — but it’s enterprise/edu only, rolling out slowly, and region-delayed. It remembers preferences, coding style, and recurring patterns across sessions.

The integrations are impressive (GitHub, Notion, Slack, Google Workspace). But integrations retrieve external context — they don’t synthesize it. There’s no mechanism for Codex to notice a recurring failure pattern and promote it to a standing rule.

What survives a session: Limited, where available. No automatic learning from patterns.

LangGraph

LangGraph has the most mature persistence story of the framework-layer options. State checkpoints to a database per thread. Long-term memory via vector stores. MongoDB integration for cross-session recall. Interrupt-and-resume for human-in-the-loop workflows.

The downside is configuration overhead. The default is amnesia — you have to explicitly wire a checkpointer and a vector store to get persistence. Most deployments don’t. And even when they do, vector similarity retrieval can miss context that’s semantically important but lexically distant from your current query.

What survives a session: Everything, if you configured the backend. Nothing, if you didn’t.

CrewAI

CrewAI has the most ambitious memory model right now. Their 2026 Unified Memory API collapses short/long/entity/external memory types into one LLM-analyzed class with composite scoring (semantic similarity + recency + importance). Cognitive Memory adds agent-driven recall flows that proactively surface context.

ChromaDB + SQLite as the default backend means persistence works out of the box. The scoping system (/, /project/alpha, /agent/researcher/findings) handles multi-agent setups cleanly.

The risk: encoding and recall flows can disagree on importance. Agents may over-weight recency. And it’s tied to the CrewAI framework — you can’t take your memory layer to a different tool.

What survives a session: Full memory hierarchy, if the database persists. Learning is automatic but not human-validated.

AutoGen

AutoGen’s memory is an afterthought. The default is stateless. You can plug in ChromaDB, Redis, Neo4j, Mem0 — but nothing is configured out of the box, and the framework itself is now in maintenance mode as Microsoft shifts focus to their broader Agent Framework.

What survives a session: Nothing by default. Optional external backends if you wire them yourself.

Pi (pi.dev)

Pi is by Mario Zechner and it’s the most honest harness on this list. The tagline is “there are many coding agents, but this one is mine.” That’s not a joke — it’s the design philosophy.

Pi is a minimal terminal harness that supports 15+ LLM providers and a TypeScript extension system. No MCP. No built-in sub-agents. No permission popups. No memory layer baked in. The core is four tools: Read, Write, Edit, Bash. Everything else — sub-agents, sandboxing, RAG, persistence — you build via extensions or you don’t have it.

Session state uses tree-structured storage so you can branch from any previous point, which is genuinely useful. Context loading comes from AGENTS.md and SYSTEM.md files at the project root. Auto-summarization handles compaction. That’s it.

The absence of a memory layer isn’t an oversight. Pi’s bet is that most harnesses bundle too much and the right answer is primitives you can compose. I find that compelling. The downside is you have to build the memory layer yourself — or bring one in from outside.

What survives a session: Tree-structured session history you can branch from. No cross-session learning without an external brain.

The problem none of them fully solve

Every system above has at least one of these gaps:

No episodic layer — no record of what the model actually did, tool by tool, session by session
No promotion mechanism — no way for recurring patterns to graduate from observations to permanent rules
Not portable — memory is locked to the framework; switching tools means starting over
No human review gate — automatic learning means automatic mistakes at scale

Most tools pick two or three of these to solve. None of them address all four cleanly.

Why I use agentic-stack

agentic-stack is not a framework. It’s a portable .agent/ folder — a structured memory system that plugs into whatever AI harness you’re actually using: Claude Code, Pi, Cursor, Windsurf, OpenCode, or a custom Python setup.

The memory structure is four layers with distinct retention policies:

working/ — current task state, cleared when done
episodic/ — timestamped records of what actually happened, tool by tool
semantic/ — durable lessons that survived human review
personal/ — your preferences, constraints, and how you like to work

The dream cycle runs at session end. It clusters episodic entries by content similarity, scores them by salience (frequency × recency × pain_score), and stages high-salience candidates for review. A human validates before anything enters semantic memory. No automatic promotion, no silent mistakes.

Recall runs before any risky operation — deploy, migration, schema change. It surfaces the most relevant past events. Not just similar keywords, but events that mattered.

The portability is the differentiator. Your .agent/ folder moves with you. Switch from Claude Code to Cursor, the memory comes along. Switch to Pi — there’s a first-class adapter for that too. Switch to a custom Python agent — same thing. Your knowledge isn’t owned by the framework.

Why this framing matters now

Six months ago, “just use Claude” was a reasonable answer for most coding tasks. Today, teams are running multi-session workflows, building internal agents with persistent context, and making architectural decisions that depend on the model having accurate memory of what was tried before.

The infrastructure layer is no longer optional. The question is whether you’re building it intentionally or stumbling into it one CLAUDE.md edit at a time.

Harness engineering is the discipline of building that layer well. It’s worth naming, worth thinking about explicitly, and worth getting right before your agent’s memory becomes a liability rather than an asset.

DSPy: The Framework for Programming LLMs (Not Prompting Them)

2026-04-09T00:00:00+00:00

I spent two years prompting LLMs before I found DSPy.

The cycle was always the same. Write a prompt. Test it on five examples. It works. Ship it. Then an edge case breaks. Add “IMPORTANT:” to the prompt. Works for two days. Model update changes behavior. Rewrite from scratch.

I had folders of prompts. v1.txt, v2_final.txt, v2_final_REALLY_final.txt. None of them documented why they worked. When something broke, I couldn’t tell if it was the prompt, the model, or the data. No version control. No tests. Just vibes.

Then I found DSPy.

What DSPy Actually Does

DSPy is a framework from Stanford NLP. The idea is simple: you don’t write prompts. You write Python.

class AnalyzeStartup(dspy.Signature):
    """Analyze a startup pitch."""

    pitch: str = dspy.InputField()
    viability_score: int = dspy.OutputField()
    strengths: list[str] = dspy.OutputField()
    weaknesses: list[str] = dspy.OutputField()
    verdict: str = dspy.OutputField()

That’s a Signature. It declares inputs, outputs, and types. DSPy compiles this into a prompt. When you need better prompts, you run an optimizer and DSPy rewrites them based on examples that work.

The mental model shift: LLMs become function calls. You declare the interface. The framework handles the implementation.

What Changed

I stopped memorizing prompt tricks.

Before DSPy: “If I put examples before instructions, it works better. Sometimes. Unless it’s GPT-4o. Then I need to structure it differently.”

After DSPy: I write a Signature. DSPy figures out the best prompt format. The prompt becomes an implementation detail. I care about inputs, outputs, and behavior.

I can finally test my LLM code.

def test_startup_analyzer():
    result = startup_analyzer(pitch="We're building AI for dog grooming...")
    assert 1 <= result.viability_score <= 10
    assert len(result.strengths) > 0
    assert len(result.weaknesses) > 0

Real tests. In my test suite. With assertions. This alone changed how I think about LLM applications.

Model swaps are one line.

lm = dspy.LM("openai/gpt-4o-mini")
# lm = dspy.LM("anthropic/claude-3-sonnet")
# lm = dspy.LM("gemini/gemini-2.0-flash")

dspy.configure(lm=lm)

Same code. Different model. DSPy handles the prompt translation. Before, every model needed prompt tuning. GPT-4 liked prompts one way. Claude another. Gemini another. Prompts were coupled to specific models. Now they’re not.

Optimizers do the tuning for me.

optimizer = BootstrapFewShot(metric=my_metric, max_bootstrapped_demos=4)
optimized = optimizer.compile(StartupAnalyzer(), trainset=train_examples)

Hand DSPy some examples of good outputs. It runs experiments, finds what works, builds the prompt. You review the results. That’s it.

Why This Matters

If you’ve spent any time in production LLM systems, you know the pain. Prompts are brittle. Model updates break things. You can’t version control a prompt the same way you version control code. You can’t write unit tests for a prompt the same way you test functions.

DSPy doesn’t solve all of this. But it moves the abstraction up one level. You’re still working with LLMs. But you’re programming them, not prompting them.

The difference between raw SQL scattered through your codebase and an ORM. One is brittle, untyped, hard to refactor. The other is structured, testable, maintainable.

When DSPy Makes Sense

You’re building something real, not a demo
You need reliability, not “it works sometimes”
You want to swap models without rewriting everything
You’re tired of the prompt treadmill

Why I Wrote a Guide

I spent two years learning DSPy by hitting every error message, debugging every silent failure, and rewriting every prompt that “worked in testing.”

I wrote down everything I learned. Practical stuff. Real code. The things nobody explains in documentation.

It’s called Harmless DSPy. Chapter 1 is free if you want to see if it’s your thing.

DSPy is developed by Omar Khattab and team at Stanford NLP. It’s open source, actively maintained, and genuinely changed how I build with LLMs.

If you’re interested in DSPy, I also wrote about using DSPy with GPT Vision for extracting structured data from images, and building knowledge graphs with DSPy.

Spec-Driven Development with AI: Why Your AI Is Guessing (And How to Stop It)

2026-04-03T00:00:00+00:00

There’s a moment every developer has felt. You give an AI a task. It comes back confident, producing code that almost works. The logic is plausible. The syntax is clean. And then you realize it invented a function that doesn’t exist, picked the wrong library, or quietly changed a data model three files away from where you were looking.

You call it a hallucination. I call it a communication failure.

The AI did not fail you. You failed to brief it.

The Briefing Problem

Think about how you actually hand off work to a contractor. You don’t walk up to a plumber and say “fix the water situation in the kitchen, you’ll figure it out.” You describe the symptoms, show them the pipes, tell them what you’ve already tried, specify what can’t be touched, and agree on what done looks like.

AI agents are contractors. Very fast, very literal contractors who will execute exactly what you communicate to them, not what you meant. The gap between what you mean and what you say is where every hallucination lives.

Most developers are still in the “you’ll figure it out” phase. They write a sentence or two, hit enter, and treat the output like a lottery ticket. Sometimes it’s great. More often it’s plausible garbage that takes longer to fix than to rewrite.

Spec-Driven Development is the system that closes that gap.

What SDD Actually Is

SDD is not a tool. It’s not a library. It’s a communication discipline.

The core idea: before you let an AI write code, you write a structured document that captures your intent, your context, your constraints, and your definition of done. That document is the spec. The AI executes against the spec, not against your vibes.

There are four things a good spec contains:

Context. What problem are you solving and why does it exist? The AI needs to understand the shape of the situation before it touches anything. “Add a login screen” is ambiguous. “Add a login screen to a React Native app using Expo Router, where the auth session is managed by Supabase, and the design system uses NativeWind” is not.

Constraints. What is not negotiable? The library. The naming convention. The folder structure. The error handling approach. Constraints are not limitations on the AI. They’re the boundaries inside which creativity is actually useful.

Tasks. What are the atomic steps to get from here to done? A task is small enough that the AI can complete it without asking a clarifying question. If a task requires judgment, it needs to be two tasks with the judgment made in writing first.

Acceptance criteria. What does done look like? If you can’t write this down, you don’t actually know what you want yet. That’s fine. Write it down until you do. The spec catches unclear thinking before it becomes unclear code.

A Concrete Before and After

Here’s the kind of prompt that produces lottery-ticket results:

“Build a user profile screen that shows the user’s info and lets them edit it.”

And here’s what that looks like when you brief it properly:

Context:
We're adding a profile screen to an existing React Native app using
Expo Router. User data lives in Supabase under the `profiles` table.
Auth is already configured.

Constraints:
- Use NativeWind for all styling. No new dependencies.
- Edit form must handle optimistic updates and roll back on failure.
- Use existing Button and TextInput components from @/components/ui.

Tasks:
1. Create app/(tabs)/profile.tsx with read-only view of display_name,
   avatar_url, and bio
2. Add Edit button that toggles inline form fields for those three values
3. On save, call updateProfile() with optimistic UI update, roll back on error
4. Show loading skeleton during initial data fetch

Done when:
- User can view and edit profile without a full page reload
- Changes persist in Supabase
- Errors show a toast notification

Same feature. Completely different conversation. The second one produces code you can actually ship.

This Is Not More Work

The pushback I always hear: “that takes too long, I’ll just iterate faster.”

You won’t. You’ll iterate at the same speed, but the iterations will be bigger and more expensive. Fixing a wrong architectural decision in week three costs ten times more than writing a constraint in week one. The spec looks like overhead until you’ve spent two hours untangling code that confidently went in the wrong direction.

Writing a spec for a focused feature takes ten minutes. It saves you the first revision almost every time.

The other thing: once you have the spec, you have the documentation. You don’t have to write it later. You don’t have to reverse-engineer intent from code six months from now. The spec is the paper trail. Check it into git next to the code and it stays honest.

The AGENTS.md Concept

Here’s how seriously the best SDD tooling takes this communication problem. OpenSpec has a file called AGENTS.md — sometimes described as “a README for robots.” It’s not documentation for humans. It’s a document where you tell your AI agents exactly how to read your project, how to format their output, and how to follow your workflow.

Think about that for a second. You’re writing instructions for the AI about how to receive instructions. That’s the level of explicitness that actually eliminates guessing. Most hallucinations happen not because the AI is wrong, but because it filled in a gap you didn’t know existed. AGENTS.md closes those gaps at the system level, not feature by feature.

You don’t need a special tool to start doing this. A CLAUDE.md or a AGENTS.md in your project root, with your stack, your conventions, and your non-negotiables, gets you 80% of the way there today.

The Mindset Shift

The real change isn’t in your tools. It’s in how you see your role.

When you vibe code, you’re a typist hoping the AI figures it out. When you spec, you’re a systems designer who gives the AI something solid to execute against.

That shift feels small. The results are not.

In the next article in this series, I’m going to break down the anatomy of a great spec in detail, with a real project and annotated templates you can steal. If you want to follow along, the companion template is below.

Next in the series: Anatomy of a Great Spec (coming next)

Companion asset: Spec vs. Prompt Cheat Sheet

Resources:

OpenSpec on GitHub
Getting Started with SDD (my original walkthrough)
Addy Osmani: How to Write a Good Spec

Made it show its work

2026-03-30T00:00:00+00:00

I wrote about phntm.sh a few weeks ago. The short version: a file sharing tool that encrypts in your browser, puts the key in the URL fragment, and forgets the ciphertext when the timer runs out. I literally cannot read your file.

Since then I’ve been heads down. Here’s what changed and why.

The landing page was lying by omission.

Not intentionally. But it said “encrypted, self-destructing file sharing” without explaining what that actually means. Most people read that and think: encrypted somewhere on a server, probably. A checkbox someone ticked.

So I rewrote it. The new hero says what’s actually happening — your file encrypts in your browser before it goes anywhere. The decryption key never touches the server. There’s a WHY section now that explains zero-knowledge, not as a buzzword, but as a specific technical decision with real consequences.

It also lists who this is actually built for: journalists, lawyers, developers. People who’ve had reasons to care about this stuff before the rest of us did.

The encryption is visible now.

This is the change I’m most proud of.

When you upload a file, the UI now shows you the cipher algorithm and key size in real-time. AES-256-GCM. 256-bit key. Client-side. You can watch it happen. The status text cycles through glyphs before resolving — like a terminal decoding something. A bit theatrical, but also accurate.

I added this to downloads too. When someone receives your file, they see the same details. Cipher. Key size. Client-side processing.

The reason this matters: trust isn’t a paragraph in a privacy policy. Trust is watching the lock turn. When encryption is invisible, it might as well not be there from a user’s perspective. Making it visible makes the claim real.

I also strip the URL fragment from analytics. The key is in the fragment. Analytics never see it. That needed to be airtight.

The CLI actually tells you what’s happening now.

The CLI went from “it works” to “it feels good to use.”

phntm send and phntm get now have step tracking. You see each stage: encrypting, uploading, done. Progress bars. Proper handling when the output file already exists (increments instead of clobbering). The ANSI rendering was cleaned up so it doesn’t break on weird terminals.

Before this it was a pipe. Now it feels like a tool.

A note on what I fixed.

There was a bug where the CLI was getting 403 errors from the server because the origin check was too strict. The CLI sends an X-Phntm-Client header and the server was rejecting it. Fixed. Also found that localhost with a port was failing origin comparisons because I was comparing the full origin string against just the hostname. Small bug, annoying to track down, obvious in retrospect.

Ran a security audit. Patched the findings. Nothing dramatic.

Both the web app and the CLI are open source. The code is how you verify the claims.

If something seems off, open an issue. That’s the whole point.

The Web Is A Cop And You Invited It In

2026-03-22T00:00:00+00:00

A few months ago I wrote that we gave up file ownership without noticing. That we handed control to corporations not because it was better, but because it was easier. I ended with “we can build something better.”

This is that something.

A file sharing service needs to do exactly one thing. Move bytes from point A to point B, then forget they existed. No accounts. No logs. No server that can read what you sent.

The technology to do this has existed for over a decade. Client-side encryption. URL fragments that browsers never send to servers. AES-256-GCM. None of this is new. Nobody bothered because collecting your data was always more profitable than respecting it.

So I built phntm.sh.

Your file gets encrypted in your browser before it goes anywhere. The decryption key lives in the URL fragment, which means I never receive it. All I store is ciphertext. Noise. I literally cannot read your file. When the timer expires, the ciphertext is destroyed. Nothing to subpoena. Nothing to leak.

The web app and CLI are both open source because “trust me” is not an architecture.

Web app: github.com/aliirz/phntm.sh
CLI: github.com/aliirz/phntm-cli / phntm.sh/cli

Spec-Driven Development Made Easy: A Practical Guide with OpenSpec

2026-01-30T00:00:00+00:00

I’ve been vibe coding for the better part of a year. You know the drill. Open Cursor or Claude Code, type something like “build me a login screen with Google auth,” and hope for the best. Sometimes it works great. Sometimes the AI hallucinates a library that doesn’t exist, picks a routing strategy you hate, or quietly breaks something three files away.

The problem isn’t the AI. It’s us. We treat coding agents like search engines when we should be treating them like literal-minded pair programmers. They’re excellent at following instructions. We’re just bad at giving them.

That’s where Spec-Driven Development comes in.

What Is Spec-Driven Development?

Spec-driven development (SDD) flips the script. Instead of coding first and documenting later, you write structured intent that AI agents execute to generate the implementation. The specification is the source of truth, not the code.

Think of it like this: you wouldn’t hand a contractor a vague description and say “build me a house, you’ll figure it out.” You’d give them blueprints. SDD is blueprints for AI agents.

The workflow breaks into four phases:

Specify - Write a plain-language markdown file defining the what and why. User goals, requirements, acceptance criteria. No technical “how-to” details yet.
Plan - Layer in the technical context. Tech stack, architectural patterns, security constraints. This is the “how” at a high level.
Tasks - Break the plan into small, reviewable steps. Each task should be atomic enough for an AI agent to implement without further clarification.
Implement - Feed these artifacts to an AI agent to generate code and tests that strictly adhere to the spec.

Why Not Just Vibe Code?

Three reasons I keep coming back to:

Reduced hallucinations. Clear constraints in a spec prevent the AI from making “creative” guesses that cause bugs. When you tell it “use expo-router for navigation,” it doesn’t surprise you with react-navigation.

Living documentation. The spec is version-controlled next to the code. It never becomes a dusty artifact nobody reads. It is the thing that drives development.

Better code reviews. Reviewers evaluate changes against the original intent rather than trying to reverse-engineer the logic from code. “Does this match what we said we’d build?” is a much easier question than “What is this code trying to do?”

The Tools

Several toolkits now automate the management of specifications:

GitHub Spec Kit - An open-source toolkit providing slash commands (/speckit.specify, /speckit.plan) to automate branch creation, template generation, and task breakdown. Works with Copilot, Claude Code, and Gemini CLI.
Amazon Kiro - An agentic development tool that guides you through requirements and design phases directly within an integrated environment.
OpenSpec - A lightweight layer for brownfield and greenfield development that helps align humans and AI on changes before code is written. Supports 24 AI tools.
Tessl - A platform where the specification itself is the maintained artifact, allowing code to be continuously regenerated.

For this walkthrough, I’m using OpenSpec. It’s lightweight, open-source, and works with whatever AI coding assistant you already have.

Building a Mobile App with OpenSpec: The Full Walkthrough

Let’s say I want to build a React Native mobile app from scratch. Here’s how I’d approach it using SDD with OpenSpec. The core loop is: Propose → Plan → Implement → Archive. You never just “ask” the AI to write code. You ask it to create a Change Proposal, align on the details, and only then authorize it to code.

Prerequisites

Node.js (v20.19+)
AI Coding Assistant: Claude Code, Cursor, or Windsurf work best since they can read your file structure and run terminal commands

Phase 1: Initialization & The “Constitution”

Before building anything, install the tool and set the ground rules.

npm install -g @fission-ai/openspec@latest

mkdir my-mobile-app
cd my-mobile-app

openspec init

This creates an openspec/ folder in your project.

Now the crucial part. Open openspec/project.md and edit it manually. This is your project’s constitution — the non-negotiable constraints every future spec must respect.

Mine looks something like:

This is a React Native app using Expo. We use TypeScript, Tailwind (via NativeWind) for styling, and Supabase for the backend. All navigation uses expo-router. We follow atomic design principles for components.

This is the single most important file in the whole process. OpenSpec injects this context into every artifact it generates — proposals, designs, tasks. It’s how you stop the AI from “forgetting” your stack choices halfway through Phase 4.

Phase 2: The Base Build (Your First Change)

Instead of manually running npx create-expo-app, treat the project setup as your first spec change.

Start the change:

In your AI chat (Cursor, Claude Code, etc.), type:

/opsx:new setup-project

Prompt: “Create a proposal to scaffold a new React Native app with Expo and TypeScript. Include a basic home screen.”

Generate the plan:

/opsx:ff

That’s “Fast Forward.” It generates the Proposal, Spec, Design, and Tasks all at once.

Review the artifacts (this is the SDD magic):

Don’t let the AI code yet. Open the openspec/changes/setup-project/ folder and check:

proposal.md — Does it understand why we’re doing this?
design.md — Did it pick the right libraries? If it chose react-navigation instead of expo-router, correct it here. Before a single line of code exists.
tasks.md — Are the steps specific and atomic? “Run init command,” “Create directory structure,” “Configure TypeScript.”

This is where SDD earns its keep. You catch architectural misalignment before it becomes 500 lines of wrong code.

Implement:

Once you’re satisfied with the artifacts:

/opsx:apply

The AI executes the tasks file line by line — running terminal commands to scaffold the app, writing the initial code, all within the constraints you defined.

Archive:

Verify the app runs in your emulator, then:

/opsx:archive

This merges your change into the “Main Spec” and clears the stage for the next feature.

Phase 3: The Development Loop

Now you build every feature — Login, Profile, Camera, whatever — using the same cycle.

Example: Adding a Login Screen

/opsx:new login-flow

Prompt: “I need a login screen. It should support Email/Password and Google Auth. Use a dark theme consistent with our existing design tokens.”

/opsx:ff

Now review:

Did the spec include error states? (Password too short, network failure, invalid email)
Is the design reusing your existing Button components or creating new ones?
Does the tasks list include writing tests?

If anything’s off, edit the markdown files directly. Then:

/opsx:apply

Test the login. If it works:

/opsx:archive

Rinse, repeat. Every feature follows the same loop.

What I’ve Learned So Far

SDD isn’t magic. It doesn’t guarantee perfect code. But it does three things that vibe coding can’t:

It forces you to think before you build. Writing a spec is harder than typing a prompt. That difficulty is the point. You catch bad ideas when they’re cheap to fix — in a markdown file, not in a tangled dependency graph.

It gives you a paper trail. When something breaks in month three, you don’t have to reverse-engineer intent from code. The spec tells you what you meant. The design tells you why you chose that approach. The tasks tell you what was supposed to happen.

It makes AI agents dramatically more reliable. Constraints reduce hallucinations. A well-specified task with clear boundaries produces better code than a vague open-ended prompt every single time.

The biggest mindset shift? Stop thinking of the AI as a coder. Think of it as a very fast, very literal contractor. You’re the architect. The spec is the blueprint. The code is just the construction.

Try It

If you want to get started, the barrier is low:

npm install -g @fission-ai/openspec@latest
mkdir your-project && cd your-project
openspec init

Edit your constitution. Write your first spec. Let the AI build from there.

Because the future of AI-assisted development isn’t about writing better prompts. It’s about writing better specs.

Resources:

Photo by Daniel McCullough on Unsplash

Writing code that writes code

2025-09-19T00:00:00+00:00

I built a multi-agent system because I could. Not because the world needs another coding assistant. We have Cursor, VS Code with Copilot, Windsurf, Replit Agent, Lovable. They all do this better than what I made.

But I wanted to see what happens when you give different AI agents different tools and watch them try to collaborate. Mostly out of curiosity. I have built multi agent systems before but never with the Claude Code SDK.

The Setup

Four specialized agents:

File Manager: Creates and edits files
Code Executor: Runs commands and code
Analyst: Reviews and audits code
Coordinator: Plans and delegates

Each agent only gets the tools it needs. No more, no less. File Manager can’t execute code. Code Executor can’t analyze patterns. Real separation of concerns.

What Happens

Ask it to build a FastAPI server and something interesting happens. The agents start talking to each other through their actions:

file_manager: Creates main.py (with bugs)
code_executor: Tries to run it, fails
analyst: Points out the import error
file_manager: Fixes it
code_executor: Runs again, works this time

The code they write is actually decent. Clean structure, proper error handling, reasonable patterns. Good enough for prototypes you’d actually use.

The Code

async def run_agent_task(self, agent_type: AgentType, task: str):
    options = self._create_agent_options(agent_type)
    async with ClaudeSDKClient(options=options) as client:
        await client.query(task)
        async for msg in client.receive_response():
            # Actually creates files, runs commands, etc.

Using ClaudeSDKClient gives you real power. Not just text completion. Actual file system access. Actual command execution.

What I’m Learning

The main thing is watching what happens when you force specialization. When the File Manager agent can’t run code, it has to write more carefully. When the Code Executor hits errors, it has to ask for help.

It’s like pair programming, but with artificial constraints that force actual collaboration.

What It Actually Builds

A working FastAPI server with proper routing
A data scraper that handles errors gracefully
A web dashboard with actual functionality

Not groundbreaking, but solid prototypes you could build on. The kind of code you’d write yourself if you were moving fast.

Why Bother?

Honestly? Because I was bored and the Claude Code SDK was sitting there. Building something that builds something else felt like a fun weekend project.

Sure, it’s inefficient compared to just using Cursor. But efficiency wasn’t the point. Curiosity was.

What I Learned

Building this taught me more about the Claude SDK than any documentation would. Watching agents fail and recover gave me ideas for how to structure my own code better.

Also, there’s something satisfying about building a system that builds systems. Even if those systems are basic. Even if better tools exist.

Sometimes you build things just to see if you can. This was one of those times.

The code is on GitHub if you want to mess with it. It’s actually pretty useful for quick prototypes.

Because sometimes the most important thing isn’t what works perfectly. It’s what works at all.

Photo by Tai Bui on Unsplash

Remember when we owned our files?

2025-08-05T00:00:00+00:00

There was a time when we controlled our data. You didn’t need permission from a company to send someone a file. You didn’t need an account. You didn’t need to agree to anything. You just shared it. One computer talked to another. That was enough.

It wasn’t perfect. It broke sometimes. But it worked. And it belonged to us.

Now, every photo, document, or message has to pass through someone else’s server. We hand it over. We wait. We trust. Most people don’t even think about it. They’ve been told this is just how the internet works.

But it’s not how the internet was designed. It’s not how it has to be.

We’ve centralized everything. We’ve given up control. We’ve accepted that our files live in someone else’s system, under someone else’s rules. Not because it’s better. Because it’s easier. Because it’s what we were told to do.

And in doing that, we gave up something important. Autonomy. Privacy. Simplicity. The idea that two people can talk to each other without a corporation sitting in between.

We can do better. The tools exist. Encryption is stronger. Networks are faster. We can build systems that are secure, private, and truly ours.

But we have to care enough to try.

We have to remember what we had. And why we gave it up.

Not to go back. But to build something better.

And this time, to keep it.

Photo by Jon Tyson on Unsplash

TICTeC 2025

2025-07-22T00:00:00+00:00

Sometimes I hate the fact that I was born in Pakistan… well, not sometimes, just whenever my visa gets rejected for no clear reason.

This year I was invited to speak at TICTeC 2025 in Belgium. I was super excited as I would get a chance to talk about my passion for AI and democracy. I was going to present Numainda as a case study. The TICTeC team made sure I had tickets and reservations all set up.

I applied for my visa at VFS’s new office in Chata Bakhtawar. The whole process itself was time-consuming and cumbersome. My visa appointment was set at 10 am and I got free from it all finally around 6 pm. They don’t allow you to take phones with you and make you run for exchanging currency to euros, just FYI.

Khair, I applied grinding my teeth at all times and then I waited. With the date for the conference fast approaching, I realized that I would not be able to get it on time. I tried everything I could to learn more about it but to no avail.

Gemma and her team offered me to present virtually, which I accepted gladly. So here is my talk:

While the visa process was frustrating and ultimately unsuccessful, this experience taught me that opportunities can still come through alternative means. The TICTeC team’s flexibility and willingness to accommodate virtual participation shows that the global tech community values diverse voices, regardless of bureaucratic hurdles.

I hope that one day, Pakistani citizens won’t have to face such lengthy and uncertain visa processes. One can only hope 🥹.

Chain of Draft (CoD): Making LLMs Think Like Humans on a Deadline

2025-04-15T00:00:00+00:00

Ever watched someone solve a tough problem while pacing, scribbling half-sentences, muttering “carry the two…” under their breath? That’s how we humans reason. We don’t narrate full essays in our heads. We sketch ideas. And that’s exactly the vibe of Chain of Draft (CoD).

CoD is like giving your LLM a sticky note and saying: “Solve this, but keep it tight. No TED Talks.”

So what is Chain of Draft, really?

It’s a prompting strategy from a recent paper “Chain of Draft: Thinking Faster by Writing Less”. Instead of long-winded Chain of Thought (CoT) answers where the model explains every mental detour, CoD asks it to reason in fast, minimal bursts—5 words max per step.

Imagine you’re doing mental math in a checkout line and the person behind you is sighing loudly. That’s CoD.

Why should you care?

Because:

You get the same accuracy (sometimes better)
You save on tokens (92% fewer, no joke)
You get answers faster (less to compute = more speed)
It works on logic, arithmetic, QA, multi-hop tasks

This is ideal when your app’s running a fleet of agents and one of them decides to write a memoir. CoD stops the oversharing.

The Showdown: CoD vs CoT

Feature	Chain of Thought (CoT)	Chain of Draft (CoD)
Style	Rambling essay	Bullet points with a mission
Token Usage	High	Low (like, really low)
Speed	Slower	Fast and snappy
Accuracy	Great	Also great
Cost	$$$	$
Interpretability	High	Medium (still readable though)

Try it Yourself

import os
from openai import OpenAI

# Initialize the OpenAI client with your API key
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def chain_of_draft_prompt(question):
    return f"""You're a reasoning expert. Solve this problem using extremely 
    short steps (5 words max). Then, give the answer.

    Question: {question}

    Steps:
"""

# Create a chat completion
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": chain_of_draft_prompt("What’s 23 * 17?")}
    ],
    temperature=0.3
)

# Print the assistant's reply
print(response.choices[0].message.content)

TL;DR

Chain of Draft is the minimalist cousin of CoT. It doesn’t talk much, but it gets things done.

Use it when:

You want results, not rambling
You’re running at scale
Token bills are getting ridiculous
Your agents are thinking like poets, not engineers

All Things Devcast Episode 1

2025-01-28T00:00:00+00:00

I’ve launched All Things Devcast, my new podcast diving deep into the world of artificial intelligence and software development. This podcast aims to bridge the gap between cutting-edge AI technology and practical implementation in the developer’s world.

In each episode, we’ll explore practical tips, engage in thought-provoking discussions, and share actionable insights that you can apply to your tech projects. Whether you’re a seasoned developer, tech leader, or just someone passionate about staying ahead in the rapidly evolving tech landscape, there’s something here for you. The first episode is now live! Check it out:

Building Knowledge Graphs Using DSPy

2025-01-03T00:00:00+00:00

One of the coolest things I learned in 2024 was DSPy 1. It’s a framework for programming LLMs (not prompting). It’s a great way to build LLM applications.

We have helped build some cool applications using DSPy. We deployed a License information extractor at TRA 2 and a couple of smart agents at Revreply 3 for scoring and validating emails before they are sent out. I made my first ever open source contribution to DSPy in 2024 albeit small but still meaningful.

At boostpanda we are working on the next generation RAG agent. One of the key aspects is utilizing knowledge graphs as well as memwalker to build a faster RAG pipeline. While it’s a work in progress, I thought why not demonstrate an example of how DSPy can be used to extract knowledge graphs from text.

So in true indie hacker spirit, as part of my 100 days of AI challenge, I decided to build a DSPy program that extracts knowledge graphs from text:

class EntityRelations(BaseModel):
    first_entity: str = Field(..., description="The first entity in the relationship")
    relationship: str = Field(..., description="The relationship between the two entities, should be a verb")
    second_entity: str = Field(..., description="The second entity in the relationship")

class EntityExtraction(dspy.Signature):
    text: str = dspy.InputField(desc="The text to extract entities from")
    entities: EntityRelations = dspy.OutputField(desc="Entities and their relationships extracted from the text")


def extract_entities_and_relations(extractor, sentence):
    prompt = f"Identify the main entities and their relationship in the sentence: '{sentence}'"
    response = extractor(text=prompt).entities.model_dump()
    keys = ['first_entity', 'relationship', 'second_entity']
    return tuple(response[key] for key in keys if key in response)

def build_knowledge_graph(extractor, text):
    sentences = sent_tokenize(text)
    graph = nx.DiGraph()

    for sentence in sentences:
        try:
            entity1, relationship, entity2 = extract_entities_and_relations(extractor, sentence)
            if entity1 and entity2:
                graph.add_node(entity1)
                graph.add_node(entity2)
                graph.add_edge(entity1, entity2, relation=relationship)
        except Exception as e:
            print(f"Failed to extract or add entities for the sentence '{sentence}': {e}")

    draw_knowledge_graph(graph)

def draw_knowledge_graph(graph):
    pos = nx.spring_layout(graph)
    plt.figure(figsize=(12, 12))
    nx.draw(graph, pos, with_labels=True, node_size=300, node_color="skyblue")
    edge_labels = nx.get_edge_attributes(graph, 'relation')
    nx.draw_networkx_edge_labels(graph, pos, edge_labels)
    plt.title("Knowledge Graph")
    plt.show()

def configure_dspy():
    api_key = userdata.get('OPENAI_API_KEY')
    if not api_key:
        raise ValueError("API key for OpenAI is not set in environment variables.")
    llm = dspy.OpenAI(
        model='gpt-4o',
        api_key=api_key,
        max_tokens=400
    )
    dspy.settings.configure(lm=llm)
    return dspy.TypedPredictor(EntityExtraction)


entity_extractor = configure_dspy()



text = """
On a bright sunny day, not too far, not too near,
Lived two silly sisters, so full of cheer.
Anaya was seven, Liyana just five,
When they had an idea that came alive!

“Let’s build a machine!” Anaya declared.
“One that eats socks!” (Liyana just stared.)
“Why socks?” Liyana asked, scratching her head.
“Because eating bananas is boring,” she said.

So they grabbed a big pot and a very small spoon,
A trumpet, a toaster, and a bright red balloon.
They piled it all high, till it looked like a blob,
“This is perfect!” said Anaya, “Let’s call it Bob!”

Bob rumbled and grumbled, it clanked and it beeped,
Then suddenly WHOOSH! Out came a leap!
A sock shot out high, like a rocket in space,
It landed, of course, on poor Liyana’s face"""
build_knowledge_graph(entity_extractor, text)

The output is a knowledge graph that looks like this:

I am so excited about this. I think this is a great way to extract knowledge graphs from text.

Python Best Practices: Code This, Not That 🐍

2024-11-28T00:00:00+00:00

Writing Python code is easy, but writing Pythonic code? That’s an art! Let’s explore some Python best practices that will level up your coding game. We’ll use these emojis to rate different code approaches:

💩 Avoid this code
🤔 OK, but not utilizing Python’s features
🐍 Pythonic way
💡 Bonus tips

1. Elegant Null Checks

Let’s start with something we do all the time - checking if a variable is not null (None in Python).

# 🤔 OK but verbose
name = "Claude"
if name is not None:
    print(f"Hello {name}!")

# 🐍 Pythonic and clean
if name:
    print(f"Hello {name}!")

💡 Pro tip: Use f-strings for string formatting. They’re more readable and faster than older methods!

2. List Operations Like a Pro

Checking if an item exists

languages = ["Python", "JavaScript", "Ruby"]
target = "Python"

# 🤔 The long way
found = False
for lang in languages:
    if lang == target:
        found = True
        break

# 🐍 The Pythonic way
found = target in languages

List Comprehensions

Want to transform a list? Forget the loops!

numbers = [1, 2, 3, 4, 5]

# 🤔 Traditional approach
squares = []
for n in numbers:
    squares.append(n ** 2)

# 🐍 Pythonic magic
squares = [n ** 2 for n in numbers]

# 💡 Bonus: Dictionary comprehension
square_dict = {n: n**2 for n in numbers}

3. The Power of any() and all()

Need to check conditions across a collection? Python has your back!

scores = [85, 92, 78, 90, 88]

# 🤔 Old school way
passed = True
for score in scores:
    if score < 60:
        passed = False
        break

# 🐍 Pythonic perfection
passed = all(score >= 60 for score in scores)

# 💡 Using any() for finding failing grades
has_failing = any(score < 60 for score in scores)

4. Smart Iterations

Stop counting indices when you don’t need to!

fruits = ["apple", "banana", "cherry"]

# 🤔 The index way
for i in range(len(fruits)):
    print(f"{i+1}. {fruits[i]}")

# 🐍 Pythonic enumeration
for i, fruit in enumerate(fruits, 1):  # Start counting from 1
    print(f"{i}. {fruit}")

# 💡 Bonus: Parallel iteration with zip
prices = [1.0, 0.5, 2.0]
for fruit, price in zip(fruits, prices):
    print(f"{fruit}: ${price}")

5. Context Managers: The Safe Way

Always use context managers for resource handling:

# 💩 Dangerous way
f = open("data.txt", "w")
f.write("Hello World!")
f.close()  # What if an exception occurs before this?

# 🐍 Safe and clean
with open("data.txt", "w") as f:
    f.write("Hello World!")  # File closes automatically!

6. Mutable Default Arguments

Here’s a common pitfall that even experienced Python developers sometimes miss:

# 💩 Dangerous way
def append_to_list(item, target=[]):  # DON'T do this!
    target.append(item)
    return target

# First call works as expected
print(append_to_list(1))  # [1]
# But the second call might surprise you
print(append_to_list(2))  # [1, 2] Oops!

# 🐍 Pythonic way
def append_to_list(item, target=None):
    if target is None:
        target = []
    target.append(item)
    return target

7. Generator Expressions

When working with large datasets, generators can save memory:

# 🤔 Memory-hungry way
sum([x * x for x in range(1000000)])

# 🐍 Memory-efficient way
sum(x * x for x in range(1000000))

Conclusion

Writing Pythonic code isn’t just about being fancy - it’s about writing code that’s:

More readable
Less prone to bugs
More maintainable
Often more performant

Remember, Python’s motto is “Simple is better than complex.” These patterns help you write code that’s both simple AND powerful!

Want to learn more? Check out Python’s Zen of Python by typing import this in your Python interpreter!

Happy coding! 🐍✨

GPT Vision and DSPY towards smarter automation

2024-08-22T16:54:00+00:00

Recently, I was presented with an intriguing challenge by a client. They were using a tablet-based point of sale (POS) system to sell memberships. The process involved a salesperson entering the buyer’s information and then having the buyer provide their signature after verifying all the details. However, once the contract was generated, it frequently failed validation because the details entered by the sales rep didn’t match the buyer’s license. This discrepancy wasted a significant amount of time and effort.

While investigating this issue, I discovered that the app was already capturing and storing an image of the buyer’s driver’s license. This sparked an idea: why not use Optical Character Recognition (OCR) to convert the driver’s license image into text and pre-fill the form? However, just using OCR wasn’t enough; the extracted information needed to be structured properly in JSON format. It became clear that I needed a Large Language Model (LLM) to achieve this. Eventually, I implemented a solution using Google Vision AI combined with GPT-4o, and it performed quite well.

Although the initial solution was effective, I knew it could be improved further. That’s when I turned to DSPY, a framework designed to program (not just prompt) language models. I decided to fully integrate GPT Vision with DSPY, allowing me to read the image and receive structured JSON with a single API call. Since DSPY didn’t have a built-in abstract LM class to support GPT Vision, I had to do some digging online and on GitHub. Here’s what I found:

import requests
import base64
import re
from dsp import LM

def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

"""
GPTVision is a class that extends the LM class from dsp.py
"""
class GPTVision(LM):

    def __init__(self, model, api_key):
        super().__init__("gpt-4o")
        self.model = model
        self.api_key = api_key
        self.provider = "openai"

        self.history = []
        self.base_url = "https://api.openai.com/v1/chat/completions"

    def basic_request(self, prompt, **kwargs):
        pattern = r'^Image Path: .*'
        matches = re.findall(pattern, prompt, re.MULTILINE)

        image_path = matches[1].replace("Image Path: ", "")
        for match in matches:
            prompt = prompt.replace(f"\n{match}\n", "")

        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        base64_image = encode_image(image_path)

        data = {
            **kwargs,
            "model": "gpt-4o",
            "messages": [
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "text",
                            "text": prompt
                        },
                        {
                            "type": "image_url",
                            "image_url": {
                                "url": f"data:image/jpeg;base64,{base64_image}"
                            }
                        }
                    ]
                }
            ],
            "max_tokens": 1024
        }
        response = requests.post(self.base_url, headers=headers, json=data)
        response = response.json()

        self.history.append({
            "prompt": prompt,
            "response": response,
            "kwargs": kwargs
        })

        return response
        

    def __call__(self, prompt, only_completed=True, return_sorted=False, **kwargs):
        responses = self.basic_request(prompt, **kwargs)
        print(responses)
        completions = [choice["message"]["content"] for choice in responses["choices"]]

        return completions

The above implementation worked beautifully, especially when combined with my signature:

import dspy

class VqaCoT(dspy.Signature):
    """Extract the following demographic fields from the US driver license image and return them in JSON format. If a field is not found, return an empty string for that field. The fields to extract are:

                - Full Name (ignore titles or job descriptions such as 'Motorist')
                - First Name (If it contains a middle name such as Lori Lee or Yasir N, just pick up the first name and ignore the middle name)
                - Last Name (Its always at the very beginning right next to 1 usually)
                - Middle Name (If no middle name is present, return an empty string)
                - Date of Birth
                - Gender
                - Address (including street, city, state, and zip code. Sometimes the demographics have numbers against them, like the address might have something like 8 145 Street. We need to make sure we dont pick up the serial numbers)
                - License Number (Its always at the top and the first field that looks like a license number such 4965454 or R-140-428-730-065. The title is sometimes LIC NO or ID)
                - Issue Date
                - Expiration Date"""

    image_path = dspy.InputField(desc="Base64 format of the image")
    
    demographics = dspy.OutputField(desc="""{
                    "Full Name": "",
                    "First Name": "",
                    "Last Name": "",
                    "Middle Name": "",
                    "Date of Birth": "",
                    "Gender": "",
                    "Address": {{
                        "Street": "",
                        "City": "",
                        "State": "",
                        "Zip Code": ""
                    }},
                    "License Number": "",
                    "Issue Date": "",
                    "Expiration Date": ""
                }}""")

So far, I am quite satisfied with this implementation. I’m not sure what I’ll add next, but I’m excited about the possibilities!

Mastering Markdown; A Cheatsheet from a Dev Who Loves Markdown (But Keeps Googling It)

2024-06-26T15:54:00+00:00

I have a deep love for Markdown .It’s the magical tool that turns plain text into beautifully formatted documents. But here’s a little secret: even with over 10 years in tech, I still find myself googling how to format Markdown. So, I decided to write this cheatsheet to end my relentless web searches

Headers

Use `#` for headers. The number of `#` symbols at the beginning of the line indicates whether it's a heading 1, 2, 3, etc.

# H1
## H2
### H3
#### H4
##### H5
###### H6

Emphasis

Use * or _ for emphasis.

*italic* or _italic_
**bold** or __bold__
***bold and italic*** or ___bold and italic___

Lists

Unordered List

Use -, *, or + for unordered lists.

- Item 1
- Item 2
  - Item 2a
  - Item 2b

Ordered List

Use numbers for ordered lists.

1. Item 1
2. Item 2
   1. Item 2a
   2. Item 2b

Links

Use [text](URL) for links.

[Ali Raza](https://www.aliirz.com)

Images

Use ![alt text](URL) for images.

![Markdown Logo](https://markdown-here.com/img/icon256.png)

Blockquotes

Use > for blockquotes.

> This is a blockquote.

Code

Inline Code

Use backticks for inline code.

`code`

Code Blocks

Use triple backticks for code blocks.

```javascript
function helloWorld() {
console.log("Hello, world!");
}
```

Horizontal Rules

Use ---, ***, or ___ for horizontal rules.

---
***
___

Tables

Use | to create tables.

| Header 1 | Header 2 |
|----------|----------|
| Cell 1   | Cell 2   |
| Cell 3   | Cell 4   |

Strikethrough

Use ~~ to strikethrough text.

~~This was a mistake.~~

Task Lists

Use - [ ] for task lists.

- [x] Completed task
- [ ] Incomplete task

Footnotes

Use [^1] for footnotes.

Here is a footnote reference[^1].

Emoji

Use colons to include emoji.

:smile: :+1: :heart:

Building a PDF Chatbot

2024-06-03T09:03:00+00:00

I’ve been quietly working on a personal challenge: 100 days of AI. As part of this journey, I built a chatbot that lets you chat with a PDF file. Using GPT-4 and the Assistants API, my bot can help you interact with the content of any PDF you upload.

I used Bun, Next.js, GPT-4o, and ShadCN/Tailwind. It’s been a fun and rewarding experience combining these technologies to create something I’ve always wanted to.

Here is a demo:

Feel free to explore the code on GitHub!

https://github.com/Boost-Panda/sleek-doc-api

https://github.com/Boost-Panda/sleek-doc-ui

Using Google Gemini to build Karachi Chal

2024-05-05T14:03:00+00:00

The Inspiration Spark

Picture this: I’m on a flight to Karachi, a megacity I’ve always felt a connection to, when it hits me. The sheer scale of the place, the energy – there had to be a better way to navigate it than generic travel guides. Enter Karachi Chal, my AI-powered itinerary planner! Sometimes, even when you think you’re escaping work to clear your head, inspiration strikes in the most unexpected places. That flight to Karachi turned into an accidental coding adventure! With its bustling streets and hidden gems, I knew there had to be a way to help visitors – and tourists like myself – experience the city’s true spirit. Powered by Google’s Gemini API, it quickly became more than a side project; it was a deep dive into building web apps with the power of advanced language models.

Gemini API: Your AI Copilot

Gemini is a super-smart language model from Google AI that can generate text, translate languages, write different kinds of creative content, and answer your questions in an informative way. It also has multimodal capabilities.

For Karachi Chal, I needed more than just an AI that could spit out search results. Gemini’s the perfect fit because it can understand complex requests and go beyond the typical tourist traps. For example, if a user asks, “Help me find offbeat Karachi experiences, things most tourists wouldn’t know about. I am here for 3 days,” Gemini could tap into its knowledge of Karachi to suggest.

The Code Behind the Magic

Let’s start by bringing in the necessary tools. The first line imports the core Gemini functionalities from Google’s library. MarkdownIt will help us format the AI’s responses for the web, and your style.css keeps everything looking good. Of course, we need your super-secret API key to communicate with Gemini!

import { GoogleGenerativeAI, HarmBlockThreshold, HarmCategory } from "@google/generative-ai"; // Bringing in the tools to work with Gemini
import MarkdownIt from 'markdown-it'; // Library to make the AI's output look nice
import './style.css'; 

// Your API Key - Keep it Safe!
let API_KEY = import.meta.env.VITE_GEMINI_KEY;

This is where I teach Gemini how to be the ultimate Karachi travel guide. By setting the ‘role’ to ‘user’, I’m making sure the AI understands this input is coming from someone asking for help. Inside the ‘parts’ is where I’ll carefully craft instructions for creating the perfect itinerary:

let contents = [
    {
        role: 'user',
        parts: [
                    // Your prompt text here 
                ]
        }
    }
];

Now here is the real Jugaar (hack), the prompt that makes Karachi Chal tick:

let contents = [
    {
        role: 'user',
        parts: [
                    { text:  `You are a knowledgeable travel guide specializing in Karachi. 
                    When a visitor asks you about their upcoming trip using the 
                    variable "${promptInput.value}", provide a comprehensive response. 
                    Include detailed daily itineraries, top dining spots, and must-see attractions. 
                    Ensure you account for travel logistics, such as travel times and 
                    operational hours of venues.` }
                ]
        }
    }
];

One of the coolest parts of building with AI is those ‘aha!’ moments. Gemini works by sending a stream of text rather than a single block, and figuring out how to handle that on the fly was a big win! Working with Markdown to make everything look good on the website added another layer to the challenge.

The End Result

For the input we used above, here is how Karachi Chal would respond:

Day 1: Discovering Karachi's Quirky Side

Morning:

Start your day by visiting the ethereal Khuda Ki Basti (God's Colony), a unique neighborhood adorned with vibrant street art and murals by local and international artists. Spend about an hour exploring its colorful streets.
Afternoon:

Head to the bustling Tower Market for a sensory overload. Wander through its maze-like alleys, marveling at the vibrant fabrics, handicrafts, and delicious street food. Allow 2-3 hours for shopping and lunch.
Evening:

Immerse yourself in the local culture at Pakka Qila (Association of the Faithful). Witness traditional wrestling matches or indulge in mouthwatering street delicacies at this vibrant public space. Stay for about 2 hours.
Day 2: Architectural Wonders and Culinary Delights

Morning:

Explore the grandeur of the Frere Hall (City Library), a majestic Gothic Revival building. Admire its intricate architecture and delve into its extensive collection of books. Visit for approximately 2 hours.
Afternoon:

Visit the picturesque Haleji Lake, a serene wetland home to diverse birdlife. Take a boat ride or stroll along its scenic shores, enjoying the tranquil atmosphere. Allow 3-4 hours for this excursion.
Evening:

Indulge in authentic Sindhi cuisine at Sohni Dharti Restaurant. Savor flavorsome dishes like sajji (grilled meat) and bhel puri (spicy puffed rice). Dinner takes about 2 hours.
Day 3: The Soul of Karachi

Morning:

Discover the fascinating history and culture of Karachi at the Pakistan Maritime Museum. Explore its exhibits on naval history, marine life, and the role of the Pakistani Navy. Plan for 2-3 hours at the museum.
Afternoon:

Immerse yourself in the vibrant atmosphere of Kemari Town, a historic fishing village. Witness the bustling fish market, interact with friendly locals, and savor fresh seafood at roadside stalls. Dedicate 2-3 hours to this experience.
Evening:

End your Karachi adventure at the Mohatta Palace, a stunning palace built in the Rajput architectural style. Admire its intricate carvings and serene gardens, while enjoying a memorable dinner at its in-house restaurant. Allow 2-3 hours for dinner and exploration.
Travel Logistics:

Getting Around: Use ride-sharing apps like Careem or Uber for convenient transportation.
Local Transport: Explore the city by rickshaw for an authentic experience.
Travel Times: Factor in approximately 30-60 minutes for travel between attractions.
Operating Hours: Venues typically open around 9 AM and close between 6 PM and 9 PM. Check specific venues for exact hours.

The possibilities are endless with Karachi Chal! Think about tweaking the prompt for a budget-friendly trip, a focus on Karachi’s art scene, or even adding a time-of-year element (festival season vs. quieter months).

If you’re a coder, data enthusiast, or just bursting with ideas to make Karachi Chal even better, join the adventure! Let’s turn this AI itinerary planner into the ultimate Karachi travel companion. Check out the GitHub Repo and the Website if you want to contribute or just explore the project.

ZenPad, A Minimal Markdown Editor for Distraction-Free Writing

2024-03-23T19:51:00+00:00

I recently launched Zenpad, inspired by my search for a distraction-free writing tool that’s straightforward yet powerful. Despite trying various platforms, I found them lacking in simplicity, prompting me to create Zenpad. Designed for writers who value focus, it requires no sign-up or sign-in, embodying the essence of minimalism.

My philosophy is simple: if you can’t find the right tool, it’s time to build it. Zenpad stands as a testament to this belief, offering a clean, user-centric writing experience. Here’s to celebrating the spirit of open-source innovation and the joy of crafting tools that resonate with our needs.

Sora, A New Horizon in AI-Generated Video Content

2024-02-15T18:20:00+00:00

Like a RKO out of nowwhere, OpenAI has unveiled Sora, a AI model designed to transform text instructions into realistic and imaginative video scenes. This launch marks a significant milestone in AI’s capability to understand and simulate the physical world in motion, opening up unprecedented possibilities for creators across the globe.

What is Sora?

Sora is not just any AI model; it is a technology capable of generating up to a minute-long videos that maintain visual quality and adhere closely to the given prompts. Developed by OpenAI, it represents a leap forward in the field, aiming to bridge the gap between imagination and visual representation without the need for extensive video production resources. OpenAI’s website.

Impact on the Video Generation Ecosystem

The introduction of Sora into the market is set to redefine the competitive landscape for startups and established companies alike in the AI-generated video space. Here’s how it impacts other players:

Runway AI: A generative AI video editing platform, enabling users to produce short video clips from text prompts.
Stability AI: Entered the video generation domain with Stable Video Diffusion, a model for generating videos from images.
Inworld AI: Specializes in creating AI-powered characters for video games and digital entertainment, using natural language processing for lifelike interactions.
Steve.ai: An online platform transforming text prompts into animated videos, targeting content creators for efficient video production.

Other notable companies in this space include:

Synthesia: For professional-looking AI videos from text.
Deepbrain AI: For conversational AI avatars and AI video generator.
Pika: Focuses on editing and generating videos from captions and still images.
Neosapience: Featuring Typecast’s Online AI Voice Generator for video content.

Opportunities for Creators and Businesses

Sora opens up a world of possibilities for visual artists, filmmakers, and designers, providing them with a tool to bring their visions to life without the traditional barriers of video production. This democratization of content creation has the potential to spur a new wave of creativity and innovation, enabling personalized and engaging content across various sectors, including education, marketing, and entertainment.

Look at some amazing video examples here OpenAI’s website.

Using Crew AI to detect fake news with your own LLM

2024-02-07T08:19:35+00:00

I found out about crew ai some time ago. While the use of multiple AT agents to perform a task is not something new. Crew AI serves as a framework to make this a lot more easier. The best part is that it lets you define your agents and their tasks in a very organized manner. I have been playing with it for a while now and I did a small experiment to see if I could use it to detect fake news.

One of the most powerful features that Crew AI has is the ability to have your agents use tools in their tasks. For example you can have a agent use the following tool to search the web

@tool("Search the internet")
def search_internet(query):
"""Useful to search the internet 
about a a given topic and return relevant results"""
url = "https://google.serper.dev/search"
payload = json.dumps({"q": query})
headers = {
    'X-API-KEY': os.environ['SERPER_API_KEY'],
    'content-type': 'application/json'
}
response = requests.request("POST", url, headers=headers, data=payload)
results = response.json()['organic']
string = []
for result in results:
    string.append('\n'.join([
        f"Title: {result['title']}", f"Link: {result['link']}",
        f"Snippet: {result['snippet']}", "\n-----------------"
    ]))

return '\n'.join(string)

By default Crew AI uses openai’s api, you need to have the OPENAI_API_KEY as a env var available. But would it not be fun if we could use our own model? I have been playing with openhermes so I decided to give it a shot and voila! I was able to use it with crew ai.

Here is a small snippet of the code from my crews repo:

from crewai import Agent, Task, Crew, Process
from langchain.tools import tool
from langchain.llms import Ollama
ollama_llm = Ollama(model="openhermes")


from langchain.tools import DuckDuckGoSearchRun
search_tool = DuckDuckGoSearchRun()


# Define your CrewAI agents and tasks
# Define Agents
fact_checking_agent = Agent(
    role='Fact-Checking Agent',
    goal='Verify the factual accuracy of the news article or statement.',
    backstory='Expert in data verification and fact-checking, skilled in discerning truth from fiction in news reporting.',
    tools=[search_tool],
    verbose=True,
    llm=ollama_llm
)

political_analyst_agent = Agent(
    role='Political Analyst Agent',
    goal='Provide context and political analysis on Pakistan.',
    backstory='Specializes in South Asian geopolitics, focusing on Pakistan.',
    verbose=True,
    llm=ollama_llm
)

media_bias_analyst_agent = Agent(
    role='Media Bias Analyst Agent',
    goal='Assess potential biases in the news source.',
    backstory='Expert in media studies, focusing on detecting biases in news reporting.',
    verbose=True,
    llm=ollama_llm
)

public_sentiment_analyst_agent = Agent(
    role='Public Sentiment Analyst Agent',
    goal='Gauge public reaction to the news.',
    backstory='Skilled in analyzing public opinion and sentiment on social media and online forums.',
    tools=[search_tool],
    verbose=True,
    llm=ollama_llm
)
# Define a function to integrate the tools with CrewAI
def analyze_news_article(content):

    fact_checking_task = Task(
        description=f'Analyze the news article: {content} for factual accuracy. Final answer must be a detailed report on factual findings.',
        agent=fact_checking_agent
    )

    political_analysis_task = Task(
        description=f'Analyze the political context of the news article: {content}. Final answer must include an assessment of the current political situation and its credibility.',
        agent=political_analyst_agent
    )

    media_bias_analysis_task = Task(
        description=f'Evaluate the news source: {content} for biases and report on potential influences on the article\'s narrative. Final answer must include an analysis of media bias.',
        agent=media_bias_analyst_agent
    )

    public_sentiment_analysis_task = Task(
        description=f'Analyze public reaction to the news: {content} on social media and forums. Final answer must summarize public sentiment.',
        agent=public_sentiment_analyst_agent
    )


    crew = Crew(
        agents=[fact_checking_agent, political_analyst_agent, media_bias_analyst_agent, public_sentiment_analyst_agent],  #  agents
        tasks=[fact_checking_task,political_analysis_task, media_bias_analysis_task, public_sentiment_analysis_task],    #  tasks
        process=Process.sequential, # currently the only way it works
        verbose=True
    )

    result = crew.kickoff()
    return result

#  usage
final_result = analyze_news_article("Feb 8 2024 Elections have been cancelled in Pakistan. The government has declared a state of emergency. The military has taken over the country.")
print(final_result)

As you can see I am using DuckDuckGo as a tool and openhermes as the LLM. The result is a detailed report on the news article. I am still playing with it and I am sure I can make it better. But I am happy with the results so far. My news article is a fake news around the delay of elections in Pakistan. As I am writing this post, elections are due tomorrow. My crew was able to successfuly research and provide its findings on the news article. This was the output i got:

Based on the context provided, it appears that the news article is outdated or incorrect as elections are still scheduled for February 8, 2024 in Pakistan and no state of emergency or military takeover has been reported.

Pretty cool right? I am excited to see what else we can do with this. I have barely began to scratch the surface. You can checkout crew ai here.

Gesture Recognition with Python OpenCV

2024-01-21T11:19:35+00:00

A long time ago I was part of a competition where people were presenting and building some great ideas. One such startup that really inspired me was trying to build an app to recognize ASL(American Sign Language) and PSL(Pakistan Sign Language). To no one’s surprise they won the competion, however down the line 4 years from that day, that startup now works as a event management company and provides sign language interpreters for such events.

We promise big, but we deliver small. It has been part of a norm here in Pakistan. Anyhow, since I’ve never had much experience working with Computer Vision, I decided to give it a shot and see if how hard it would be build a simple gesture recognition python script. Turns out, its not that hard. I was able to build a simple app that recognizes a few gestures.

The only dependencies are opencv-python and mediapipe. You can install them using pip:

pip install opencv-python mediapipe

Here is the code:

Enjoy!

Code Roaster GPT

2024-01-02T19:19:35+00:00

While experimenting with building my own GPTs, I stumbled upon a fascinating idea. What if we could train a GPT on code and utilize it to roast code? Intrigued by the concept, I decided to give it a shot. As a result Roasty was born. Roasty is a fiesty little GPT that roasts your code (and you). While its a novel idea, its the prompt that matters and the results. So far Roasty has roasted my code and me pretty well. It has also roasted some of my friends and their code.

As an example here is the code snippet from my encodedecode.lol side project.

<template>
  <div>
    <div class="form-group">
        <textarea class="form-control" v-model="inputText" placeholder="Ready for some Base64 sorcery? Input your text!" id="floatingTextarea"></textarea>
        <br />
        <div class="d-flex justify-content-end">
          <button type="button" @click="convertTo64" :disabled="isEncoded" class="btn btn-primary" :style="{ 'marginRight': '10px' }">Encode</button>
          <button type="button" @click="convertFrom64" :disabled="!isEncoded" class="btn btn-secondary">Decode</button>
        </div>
    </div>
  </div>
</template>

  <script lang="ts">
  import { defineComponent } from 'vue'
  
  export default defineComponent({
    name: 'ConvertTo64',
    methods: {
      convertTo64() {
       this.inputText = btoa(this.inputText)
       this.isEncoded = true
      },
      convertFrom64() {
        this.inputText = atob(this.inputText)
        this.isEncoded = false
      }
    },
    data() {
      return {
        inputText: '',
        isEncoded: false
      }
    }
  })
  </script>
}

This is what Roasty had to say about it:

Ah, Vue.js meets Base64 – the peanut butter and jelly of web development, but with a side of "What were they thinking?"

First off, let's address the elephant in the room: `convertTo64` and `convertFrom64`. Ah, naming methods like they're Transformers characters. Optimus Encode and Decodetron, roll out! But seriously, how about `encodeToBase64` and `decodeFromBase64`? It's like a gift to your future self who won't remember what "64" stood for.

And then, `this.isEncoded`. I appreciate the effort to track state, but what happens when someone decodes and then re-encodes? Do we just flip-flop this boolean like a politician in election season? Consider tracking the state more robustly.

Oh, and speaking of robust – `btoa` and `atob` – the good ol' built-in duo. They're great until they meet non-Latin1 characters and throw a tantrum like a toddler denied candy. Maybe consider handling that so your app doesn't crash when it encounters an emoji. 🙃

Now, let's talk about your template. It's like a minimalist painting - there's beauty in simplicity, but a few more strokes wouldn't hurt. How about some validation or user feedback? Let the user know if something went wrong, or if they're trying to decode a string that wasn't encoded in the first place. We don't want to be decoding gibberish, do we?

Lastly, the inline style in the button – `:style="{ 'marginRight': '10px' }"`. Inline styles are like seasoning – a little goes a long way, but too much and you'll ruin the dish. Maybe consider a class? Keep it clean, keep it maintainable.

In summary:
1. Rename your methods for clarity.
2. Improve your state tracking.
3. Handle non-Latin1 characters.
4. Provide user feedback and validation.
5. Avoid inline styles.

But hey, you've got the basics down. Now, just polish it until it shines brighter than a bald man's head under a spotlight! 🌟

via GIPHY

As you can see it not only roasted me but also provided some useful feedback. I am planning to use this in my code reviews from now own. Specially when I am reviewing code from my friends. Let me know what you think about this idea. You can try it out here.

The Importance of HTTP Status Codes in Microservice and API Development

2023-10-20T04:33:35+00:00

Recently, I had a small argument with a colleague who suggested that one of our developers should determine whether a request failed or succeeded based on the returned string—specifically, whether it was empty or not. While this might seem like a straightforward approach, I strongly believe that decisions should be based on HTTP status codes, not the content of the response string. Here’s why.

The Role of HTTP Status Codes

HTTP status codes are issued by a server in response to a client’s request. They fall into various categories, each serving a specific purpose:

2xx (Success): Indicates that the client’s request was successfully received and processed. 3xx (Redirection): Suggests that further action needs to be taken to complete the request. 4xx (Client Error): Signifies that the client seems to have made an error. 5xx (Server Error): Indicates that the server failed to fulfill a valid request.

Why Are They Important?

Clarity and Consistency: Using standard HTTP status codes makes it easier for developers to understand the outcome of an API call without having to dig into the response payload.

Debugging and Troubleshooting: Status codes can quickly point developers to the root cause of an issue, whether it’s a client-side mistake or a server-side error.

Automation: Automated systems can easily interpret these codes and take appropriate actions, such as retrying a failed request or logging an error for future investigation.

Monitoring and Analytics: Tracking the frequency of various status codes can provide valuable insights into API health and usage patterns.

User Experience: Proper use of status codes can help in creating a more responsive and user-friendly application by handling different scenarios gracefully.

best-practices

Use the most specific status code for each operation. For example, use 201 Created for resource creation and 204 No Content for a successful delete operation.

Avoid using generic status codes like 200 OK for all successful operations, as it doesn’t provide enough context about what happened in the server.

Always include a message body to elaborate on the status code, especially in the case of client and server errors.

Conclusion

HTTP status codes are an integral part of API and microservice development. They offer a standardized way to communicate the status of HTTP requests, making it easier for both humans and machines to understand what’s happening. By using HTTP status codes effectively, developers can build more robust, efficient, and user-friendly applications.

So, the next time you find yourself in a debate about whether to use status codes or response strings to indicate the outcome of an API call, remember the many benefits that come with sticking to standard HTTP status codes. It could make all the difference in your project’s success.

Code for All Summit 2023

2023-10-20T04:33:35+00:00

This year marked the 10th anniversary of the Code for All, a premier gathering for civic tech enthusiasts worldwide. The summit provided a unique platform to discuss, explore, and evaluate the impact of civic tech on a global scale. I had the honor of participating in a panel discussion on open-source technology and delivering a lightning talk on one of our community efforts, “Flood Light.”

The Open-Source Panel: More Than Just Hype

The panel discussion aimed to assess the true replicability of open-source software across civic tech. I was joined by experts like Olivia Vereha from Code for Romania and Xavier Frankline from Code for Africa. We discussed why open-source works, citing examples from organizations like Mozilla and civic tech projects like Decidim. The consensus was clear: open-source is not just a buzzword; it’s a viable approach for civic tech solutions.

Flood Light: A Community-Led Crisis Response

In 2022, Pakistan faced a catastrophic climate event that led to widespread devastation. In response, Code for Pakistan launched Flood Light, an initiative to create a comprehensive data platform for flood mapping. My colleague Mubassir Hayat and I shared how this effort successfully mapped over 1,500 relief camps and connected those in need with international donors and volunteers. You can watch the full lightning talk here.

Key Takeaways from Flood Light

We highlighted the transformative power of community-led initiatives in crisis response. The project was a quick solution developed overnight using Ushahidi, collecting over 2,000 data points through crowdsourcing. This data was then used by the government and aid organizations to provide relief to the affected people.

Other Highlights and Future Directions

The summit had several sessions on AI and civic tech, which resonated with our ongoing project, Numainda. It was motivating to see that we are on the right track. I was particularly inspired by Olivia Vereha’s stories and look forward to networking more with like-minded organizations like Code for Romania.

Conclusion

The Code for All Summit 2023 was an enriching experience that left me motivated to continue our work at Code for Pakistan. The summit served as a reminder of the transformative power of technology when used for the greater good. As we move forward, our focus remains on empowering the community and creating a lasting impact.

Additional Resources

Feel free to share, comment, and stay tuned for more updates on our projects and community efforts!

insults.dev, an LLM based Insult Generator for devs

2023-09-04T19:45:00+00:00

In the grand tradition of friendly banter among developers, I embarked on a journey to create a tool that could generate light-hearted, non-offensive insults for programmers. Why, you ask? Well, because who doesn’t love a good-natured jest about their favorite (or not-so-favorite) programming language? And thus, insults.dev was born.

Insults.dev is a web application that serves up playful jabs at developers based on their chosen programming language or framework. Built using Vue.js for the frontend and FastAPI for the backend. The real star of the show, however, is OpenAI’s GPT-3, a language model so advanced it can generate text that’s almost indistinguishable from human writing. And in this case, it’s been trained to be a comedic genius.

Prompt engineering is a bit like telling a joke. You need to set it up just right to get the punchline to land. In the case of insults.dev, the punchline is the insult, and the setup is the prompt I feed to GPT-3. It took a bit of trial and error, but eventually, I found the sweet spot that consistently produced insults that were funny, relevant, and just a bit cheeky. Here is what my generate_insult function looks like:

def generate_insult(language):

    prompt = f" \
        Generate insult for a developer of {language}. "
    
    messages =  [
        {
            "role":"system",
            "content":"You are a developer insult generator that gets a \
                programming language or framework as input from the user and \
                    generates a not very offensive insult.",
        },
        {
            "role": "user",
            "content": prompt,
        }
    ]
    
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo-0613",
        messages=messages
    )
    insult = response.choices[0].message.content
    return { "insult":insult, "language":language , "prompt":prompt}

This project is part of my learning journey to get better at prompt engineering and build more significant applications that utilize LLMs. The code is all available under MIT License here at Github. I hope you enjoy it as much as I enjoyed building it. And if you have any suggestions for improvements, please feel free to open an issue or submit a pull request.

via GIPHY

Up & Running with PostgreSQL with Docker

2023-07-05T19:03:00+00:00

If you are like me and need a quick way to spin up a PostgreSQL instance with PG admin, here is a docker compose file that you can use to do that.

version: '3'

services:
  db:
    image: postgres:15
    restart: always
    env_file:
      - .env
    ports:
      - "5432:5432"
    volumes:
      - db-data:/var/lib/postgresql/data

  pgadmin:
    image: dpage/pgadmin4
    restart: always
    env_file:
      - .env
    ports:
      - "8090:80"
    volumes:
      - pgadmin-data:/var/lib/pgadmin
    depends_on:
      - db

volumes:
  db-data:
  pgadmin-data:

your .env file should look something like this:

POSTGRES_USER=postgres
POSTGRES_PASSWORD=example
POSTGRES_DB=mydatabase
PGADMIN_DEFAULT_EMAIL=admin@example.com
PGADMIN_DEFAULT_PASSWORD=example

Now all you need to dop is run docker-compose -f <yourfile>.yml up -d and you should be good to go. The PG admin will be available at http://localhost:8090 and you can use the credentials from your .env file to login. You will need to grab your docker container’s ip address to connect to the database from your local machine. You can do that by running docker inspect <container-id> | grep "IPAddress".

Enjoy!

Photo by Kevin Ku on Unsplash

My Favorite Video Games in Wes Anderson Style

2023-06-30T07:03:00+00:00

I recently tweeted a thread about this but just in case adding them all here as well.

The Witcher

Spider-Man

God of War

The Legend of Zelda

Metal Gear Solid

Animal Crossing

Mass Effect

Final Fantasy

Skyrim

Cyberpunk: 2077

Personally I would love to see a collab between Kojima San and Mr. Anderson. I think they would make a great team.

Docker Environment Variables vs Arguments

2023-05-20T10:03:00+00:00

I have worked with docker for over 7 years now and I still get confused about the difference between environment variables and arguments. In this post I try to simplify the distinction and explain when to use what.

Whats the difference between ENV and ARG variables and why should I care?

ARG and ENV in Dockerfile

ARG and ENV are ways to define variables in a Dockerfile.

ARG variables

ARG variables are only available during the build process.
ARG variables are used to pass values to the Dockerfile.

ENV variables

ENV variables are available to running containers.
ENV variables are used to set environment variables for running containers.

Using ARG and ENV together

You can use ARG values to set ENV values. This is a common way to set default values for environment variables.
For example, you could use an ARG variable to specify the name of a package to install, and then use an ENV variable to set the path to the installed package.

The following image from VSUPALOV illustrated this beautifully.

How do I use ARGs and ENV Vars?

Using ARGs

As stated above these need to be passed and defined before the build process. You would define an ARG in your Dockerfile like this:

ARG my_mighty_arg
RUN echo "the value of my mighty arg is $my_mighty_arg"

What this does is it lets Docker know that this image we are builidng should expect an argument called my_mighty_arg. A value for which we will pass when we are building our image like this:

docker build --build-arg my_mighty_arg=a_mighty_value .

so when we run this we should see something like this:

the value of my mighty arg is a_mighty_value

Thats it the ARG has served its purpose and will not be available beyond the docker build scope.

Using ENV VARS

On the other hand ENV VARS are available to the running container. Imagine passing information to your continaer via env var that populates itself through a build time ARG. You can define an ENV VAR in your Dockerfile like this:

ARG my_might_arg
ENV env_var_name=$my_might_arg

Another way is to simple pass the ENV VAR in the command line:

docker run -e env_var_name=a_mighty_value .

Conclustion

In conclusion, ARG and ENV variables are both useful tools for defining variables in a Dockerfile. ARG variables are only available during the build process and are used to pass values to the Dockerfile, while ENV variables are available to running containers and are used to set environment variables for running containers. You can use ARG values to set ENV values, which is a common way to set default values for environment variables. By understanding the difference between ARG and ENV variables, you can better manage your Docker images and containers and ensure that your applications run smoothly.

Photo by Philippe Oursel on Unsplash

Learning SwiftUI by building a URL Shortener iOS App

2023-03-22T05:19:00+00:00

Rediscovering iOS Development: From Objective-C to SwiftUI

I ws a iOS developer in a past life who started his career more than eight years ago, I have seen firsthand the remarkable evolution of the iOS ecosystem. Back in the day, Objective-C was the go-to language for developing iOS applications, and we had to deal with manual memory management without the luxury of Automatic Reference Counting (ARC). Today, we have SwiftUI, a powerful and intuitive framework that makes it easier than ever to create beautiful user interfaces across all Apple platforms.

Starting with SwiftUI

Apple introduced SwiftUI at WWDC 2019 as a powerful, easy-to-use UI toolkit that enables developers to design apps for iOS, macOS, watchOS, and tvOS using Swift code. With its declarative syntax, SwiftUI simplifies the process of building user interfaces by allowing developers to describe the UI’s appearance and behavior.

As I began my SwiftUI journey, I found Apple’s official SwiftUI tutorials to be an excellent starting point. They cover the fundamentals of building user interfaces, as well as more advanced topics like data flow and animations. Additionally, I discovered several online resources, such as articles, YouTube videos, and Stack Overflow threads, that provided invaluable insights and assistance throughout my learning process.

Building a URL Shortener iOS App

After familiarizing myself with SwiftUI concepts and syntax, I decided to create a URL shortener iOS app. This project would serve as a practical way to solidify my understanding and apply the knowledge I had acquired.

The app I built is straightforward: users enter a long URL into a text field, tap a button to generate a short URL using the Bitly API, and the resulting short URL is copied to the user’s clipboard. To ensure smooth interactions with the Bitly API, I chose to integrate the Alamofire library, which simplifies the process of making network requests.

During the development of the app, I encountered several challenges that deepened my understanding of SwiftUI. First, I learned about the @State, @ObservedObject, and @Published property wrappers, which are crucial for managing data flow and state changes in SwiftUI. Second, I explored how to present alerts based on state changes and handle user input validation. Overall, this project served as an excellent hands-on introduction to SwiftUI.

Moving Forward

My experience building the URL shortener app reinforced the importance of practice and real-world application when learning a new programming language or framework. By diving into SwiftUI and working on a practical project, I was able to grasp concepts more effectively and identify areas that required further study.

This journey has been a testament to how far iOS development has come since my early days working with Objective-C. As I continue to explore SwiftUI and apply my knowledge to more complex projects, I’m excited about the endless possibilities—from building productivity apps to creating games or even designing tools to help fellow developers. I’m eager to see where my SwiftUI journey takes me next and how it will shape my future as a developer.

The app code is open source and available on GitHub.

KYC using Plaid in a swiftui app

2023-03-09T15:19:00+00:00

I am working on something very cool these days. I am not ready to make it public yet but I can tell you that it’s a fintech app. And it’s going to be awesome!

Going back to my roots as an iOS engineer I took a deep dive into SwiftUI. I am in love with its imperative style and the fact that it’s so easy to use. I am also a big fan of Combine and the fact that it’s built into SwiftUI makes it even better.

We have to use Plaid for a key function of the app to do KYC. I was a bit worried about how to do it in SwiftUI. But it turned out to be pretty easy. Here’s how you can do it in your SwiftUI app.

Prerequisites

A Plaid account Xcode 13 or later A basic understanding of SwiftUI and MVVM architecture

Step 1: Install Plaid SDK

The first step is to install the Plaid SDK in your project. Plaid provides SDKs for iOS, Android, and web applications. In this tutorial, we will be using the iOS SDK.

You can install the SDK using Cocoapods, Carthage, or Swift Package Manager. For this tutorial, we will use Cocoapods. Add the following line to your Podfile:

pod 'Plaid'

Then, run the following command to install the SDK:

pod install

Step 2: Create a Plaid Account

If you haven’t already, create a Plaid account and sign up for the KYC service. You will need to provide some information about your app and your company. After you sign up, you will receive a client_id and public_key that you will use to authenticate your requests.

Step 3: Create a Plaid Configuration

Create a PlaidConfiguration object with your client_id and public_key. You can also set other options such as the environment (sandbox or production) and the country.

let configuration = PlaidConfiguration(clientID: "your_client_id", publicKey: "your_public_key", environment: .sandbox, country: .US)

Step 4: Present Plaid Link View

Plaid Link is a pre-built UI component that allows users to securely connect their bank accounts. To present the Plaid Link view, create a PlaidLinkView with your configuration and present it using a sheet.

struct ContentView: View {
  @State private var isPresentingPlaidLinkView = false
  @State private var plaidLinkToken: String?

  var body: some View {
    VStack {
      Button("Connect Bank Account") {
        isPresentingPlaidLinkView = true
      }
      .sheet(isPresented: $isPresentingPlaidLinkView) {
        PlaidLinkView(token: plaidLinkToken, configuration: configuration) { result in
          switch result {
          case .success(let token):
            plaidLinkToken = token
            // handle success
          case .failure(let error):
            // handle failure
          }
          isPresentingPlaidLinkView = false
        }
      }
    }
  }
}

Step 5: KYC using Plaid

You can use Plaid to perform Know Your Customer (KYC) verification using the PlaidLinkView. KYC verification is an important step in financial transactions to ensure that you are complying with regulations and avoiding fraud.

To perform KYC verification using the PlaidLinkView, you can use Plaid’s Identity API. The Identity API allows you to retrieve various types of personal information about the user, such as name, address, and date of birth, from their linked financial accounts. You can use this information to verify the user’s identity and perform KYC checks.

Here’s an example of how you could use the Identity API to retrieve the user’s name and address after they successfully link their financial account using the PlaidLinkView:

let linkView = PlaidLinkView(
    configuration: .makeTestConfiguration(),
    onSuccess: { success, completion in
        PLKPlaid.createToken(
            with: .sandbox,
            publicKey: "YOUR_PUBLIC_KEY",
            institution: .tartan,
            selectAccount: nil,
            accountFilters: nil,
            publicToken: success.publicToken
        ) { result in
            switch result {
            case .success(let tokenResponse):
                let request = PLKGetIdentityRequest(
                    accessToken: tokenResponse.accessToken
                )
                PLKPlaid.client().getIdentity(with: request) { result in
                    switch result {
                    case .success(let identityResponse):
                        let name = identityResponse.accounts.first?.owners.first?.name
                        let address = identityResponse.accounts.first?.owners.first?.addresses.first?.data?.city
                        // Use the name and address for KYC verification
                        completion(true)
                    case .failure(let error):
                        // Handle the error
                        print("Failed to retrieve identity: \(error.localizedDescription)")
                        completion(false)
                    }
                }
            case .failure(let error):
                // Handle the error
                print("Failed to create token: \(error.localizedDescription)")
                completion(false)
            }
        }
    },
    onFailure: { exit, error in
        // Handle the failure
        print("Plaid Link exited with error: \(error?.localizedDescription ?? "")")
    }
)

present(linkView)

In this example, we create a PlaidLinkView and present it. When the user successfully links their financial account, the onSuccess closure is called with a PLKSuccess object and a completion handler. Inside the closure, we call the PLKPlaid.createToken method to exchange the publicToken for an access token. If the exchange is successful, we use the access token to retrieve the user’s name and address using the PLKGetIdentityRequest and PLKPlaid.client().getIdentity method. If there is an error, we handle it by printing an error message. If the user exits Plaid Link before linking their account, the onFailure closure is called with a PLKExit object and an optional error. In this example, we handle the failure by printing an error message.

You can modify this example to retrieve other types of personal information using the Identity API, such as date of birth and social security number, depending on your KYC requirements. Be sure to review Plaid’s documentation and comply with their requirements and regulations for handling user data.

You can checkout Plaid’s documentation here

Using inject and provide in vue 3

2023-03-05T19:19:00+00:00

Vue 3 has some cool new features, including “inject” and “provide”, which allow you to share data between parent and child components without having to pass it down as props. This makes your components more modular and reusable.

“Provide” is used in the parent component to provide data, which can be anything like a string, object, or function. “Inject” is used in the child component to get access to that data.

For example, let’s say you have a “message” variable in your parent component that you want to share with your child component. You can use “provide” to make that happen:

// Parent Component
<script>
import { provide } from 'vue';

export default {
  setup() {
    const message = 'Hello from parent!';

    provide('message', message);

    return {
      message,
    };
  },
};
</script>

Then, in your child component, you can use “inject” to get that “message” variable:

// Child Component
<script>
import { inject } from 'vue';

export default {
  setup() {
    const message = inject('message');

    return {
      message,
    };
  },
};
</script>

By using “provide” and “inject”, you can make your Vue 3 components more efficient and organized. Plus, the syntax is super easy to use!

You can read more here.

Job Opening MEAN Stack Developer

2022-12-14T16:52:00+00:00

Position: Mean Stack Developer (Full-time)

Experience : 2+ years

Location : Islamabad, Pakistan (Remote)

Job Description

A flexible, proactive attitude to work and must have an Agile mindset.
Previous working experience as a MEAN Stack Developer for at least 2 years.
Expert Level Knowledge of HTML, CSS and JavaScript (including ES6).
Strong knowledge of data structures and algorithms
Excellent communications skills both verbal and written.
Understanding of non-relational and relational databases such as MongoDB, SQL.
Good hands-on experience using Angular
Experience in integrating third party APIs and services.
Ability to learn quickly and operate in a fast-paced environment.
Basic knowledge of python and flask api.

Responsibilities

Developing web-based applications using the MEAN stack, including Angular, Node.js, and MongoDB
Creating RESTful services with Node.js
Writing unit test and integration tests
Writing re-useable, testable, and efficient code

Nice to Haves

Experience working with a remote team.
Understanding of Continuous Integration and Deployment process.

If you think you fit the bill, please send your resume to SaqibHussain990@gmail.com with the subject line “MEAN Stack Developer”. Please include a link to your portfolio or GitHub profile.

Same day skunk works

2022-11-22T08:56:00+00:00

I came across this really interesting experiment by A.E Studio. They have taken this initiative to launch a tool every day. Most of us who build Saas for a living understand the importance of skunkworks software. Check out their intiative Same Day Skunk Works. Maybe you will find the motivation to build that Saas you have been thinking about for a while.

Proof of Stake vs Proof of Work

2022-11-01T21:28:00+00:00

I have loved the ethereum ecosystem ever since its inception. Sadly I have not yet gottent the opportunity to do any mainstream project on it other than some code labs for practice. We are living in wonderful times, we have witnessed a true transiton in the that breaks a monopoly and makes the system more fair. Allow me to explain in a few lines.

The Ethereum network is a decentralized blockchain that allows for the creation of smart contracts, decentralized applications (Dapps), and other decentralized applications (dapps). The network has two types of consensus: Proof of Work and Proof of Stake.

Proof of Work (PoW) is a system in which miners compete to be the first to solve a hash problem and earn the right to add a block to the chain. Miners are rewarded with ether for their work.

Proof of Stake (PoS) is a system where users who hold tokens on their Ethereum wallets earn interest for their holdings through transaction fees. Users can also choose to stake their currency, which means they lock up their funds as collateral until they receive more tokens than they’ve staked. This means that users essentially lend their money to people who have asked them if they want to use it as collateral while they mine new ether or look for blocks to win rewards from mining pools.

To summarize here is a little matrix:

Proof of Work	Proof of Stake
Miners compete to solve a hash problem and earn the right to add a block to the chain	Users who hold tokens on their Ethereum wallets earn interest for their holdings through transaction fees
Miners are rewarded with ether for their work	Users can also choose to stake their currency, which means they lock up their funds as collateral until they receive more tokens than they've staked
Requires a lot of compute power	Does not require a lot of compute power

Photo by Nenad Novaković on Unsplash

What is docker

2022-10-25T11:33:35+00:00

Docker is a containerization platform that allows us to deploy our applications inside a container and then we can easily ship that container anywhere.

Docker uses the host operating system kernel, this makes docker containers really lightweight because you don’t have to have a guest OS inside your container. This also means that you can run any type of application you want inside it since the OS is the same as the host OS.

Docker containers are isolated from each other, they share the same host OS, this means that if a container gets compromised other containers will not get affected.

You can create multiple services using docker e.g. If your project consists of front-end and back-end technologies, you can create separate images for both front & back then connect them together to form a complete application.

Docker lets you build, run, test and deploy your code in an easy way

Here is a slide deck I created to explain docker in a simple way:

FloodLight

2022-09-01T08:33:35+00:00

Pakistan has been hit by the worst flood ever this year. At the time of writing this post, the flood affected a total of over 1.5 million people. Here are a few stats:

Deaths	INJURED	ROADS DESTROYED	BRIDGES DESTROYED	HOUSES DESTROYED	LIVESTOCK DEATHS
1061	1575	3475km	157	992870	727144

While many organizations are doing the best they can to assist. Our small team at Code for Pakistan took it upon ourselves to try and crowdsource as much data as we can. Hence floodlight, something we cooked up in a few hours. You can check it out here.

Photo by Jéan Béller on Unsplash

Covid Positive Day 1

2022-01-06T15:53:35+00:00

Photo by CDC on Unsplash

Dockerize your angular app

2021-12-31T19:24:35+00:00

Happy 2020 Too! If you stubmled across this post searching for how to run your uber cool angular app using docker, you are at the right place. Lets start at the begining. This is how you would normally create a new angular app:

ng new my-app

Cool! Now here is what I do with my Dockerfile:

FROM node:14-alpine as build

WORKDIR /usr/local/app

COPY ./ /usr/local/app/

RUN npm install

RUN npm run start

Now normally this will be it but I am going kick it up a notch.

I am going to run my app on nginx using multi stage docker builds. This will help us run the app as if it would run on a production server:

FROM node:14-alpine as build

WORKDIR /usr/local/app

COPY ./ /usr/local/app/

RUN npm install

RUN npm run build

FROM nginx:latest

COPY --from=build /usr/local/app/dist/my-app /usr/share/nginx/html

EXPOSE 80

Thats it! Thats the post.

Photo by Ian Taylor on Unsplash

Adding RSS feed to your Jekyll Powered Site

2021-12-13T20:33:35+00:00

You just built your uber cool jekyll site. You just deployed it on your server. Whats this?! No RSS Feeds! Don’t sweat, I got you. See its pretty simple. you just have to do two things.

Add the jekyll-feed gem to your Gemfile

gem 'jekyll-feed'

Add it to your _config.yml file under plugins

plugins:

- jekyll-feed

Run bundle install

bundle install

That’s it. Once you build or run your website, your RSS feed will be accessible at yoursite.com/feed.xml. You are welcome. 🦄

Photo by RetroSupply on Unsplash

Fund for Engineers who want to buy an Xbox

2021-12-10T12:01:35+00:00

I am planning to make a fund to help engineers like me who can afford an Xbox but are not being allowed to buy one. You can help this glorious purpose by taking a simple poll:

Click here and support the cause

Pakistan’s National Anthem - Why do we forget?

2021-10-15T12:01:35+00:00

While searching for something entirely different we came across a discussion on quora that prompted us to think, why can’t any of us remember our national anthem?

“Wish we had a way of reading the national anthem without having to search for it on google”, said Saqib. The rest is history. We immediately bought a domain, set up a GitHub repo and hunted for TTF files for a variant Nastaliq font. Within 30 minutes we deployed qomitarana.com

So the next time you need to remind yourself what our national anthem’s words are. Remember it’s just a URL away. Oh, and the Qomi Tarana project is open source. Feel free to contribute and make it grow. Pakistan Zindabad!

Comments on clean code

2021-09-09T12:01:35+00:00

So Recently at Code for Pakistan our VP Tech. made it abundantly clear that we ought to watch Uncle Bob’s clean code video lectures. It’s a really good series of videos that make you think about the code you write everyday.

This post is not about the video series but rather about the comments I found very true and witty. Whenever Uncle Bob asks the audience to focus on a particular slide the editor cuts away and focuses on the Uncle Bob’s face. Still don’t know what I am talking about? I will let the following comments explain:

I love that no matter what background we’re coming from, no matter part of the world we are from, we are united in our hatred for the video editor.

Uncle Bob: look at this piece of code Cameraman: ah I think it’s the signal for a zoom shot of uncle bob’s face

Uncle Bob: Look at this Editor: haha you wish

“clean code - lesson 2” starts talking about the origin on the moon camera man points at an empty sofa Me: wtf am I watching

I love the lecture, but I want to make the person who edited the video write on an old chalk blackboard “I will not obscure information” about 5000x

I have got a big list of slangs for the editor

Whoever edited this: when he says “look at this” - show the board, not the person!

I hope the comments explain the level of unprofessionalism of the video editing. Thats all for now, keep writing clean code you all!

Awesome Civic Tech Ideas

2020-11-28T12:01:35+00:00

Have you ever wondered what you can do more for your city? Are you a developer with some really good software skills? Do you hunger to solve problems that a common citizen faces?

If you are trying to find an awesome idea to work on in your free time, then look no further because we at Code for Pakistan has this amazing curated list of civic tech ideas on our Github. It’s an open-source list we are trying to maintain.

Have a really cool idea that you think should be on the list? Feel free to fork and submit a pull request.

If you do end up working on any of the above ideas, please do let me know. I would love to help in any way I can.

Redeploying gov.uk Part-1

2020-11-26T12:01:35+00:00

Some unique and exciting circumstances require us to redeploy gov.uk for a government stakeholder. If I am honest, this seems like a huge undertaking. As cool as this sounds, the whole project scares me. I mean, look at this architecture diagram:

To get this behemoth of a project right, I am trying to understand its guts. It’s not your typical off the mill web application that you can fork, customize, and rebuild. It is more of a tech stack to build applications on top off.

The recommended way to build applications for gov.uk is to use their docker based dev environment. Let’s see how far I get. This is the first of a series of posts I will be making on this expedition

Up and Running with TimescaleDB

2020-04-08T05:33:35+00:00

I’ve been getting into time-series databases over the past few months. I got into playing with TimescaleDB and was super impressed with its capabilities. One of the important things to understand is that TimescaleDB is just Postgres at its core which means technically TimescaleDB is an extension. Following is my usual MO to quickly run an instance of TimescaleDB.

Getting a docker container up:

docker run -d --name timescaledb -p 5434:5434 -e POSTGRES_PASSWORD=password timescale/timescaledb:latest-pg11

Connecting to said docker container:

docker exec -it timescaledb psql -U postgres

Creating your database:

CREATE database tstutorial;

Connecting to your new database:

\c tstutorial

Adding the TimescaleDB extension:

CREATE EXTENSION IF NOT EXISTS timescaledb CASCADE;

That’s it! Now you have a dockerized TimescaleDB instance up and running.