DEV Community: kennedy

I Built a SaaS That Got 0 Users. Here's What I Learned About Actually Finding Problems Worth Solving.

kennedy — Thu, 25 Jun 2026 15:56:45 +0000

Last year I spent six months building a SaaS product. I did everything "right", polished UI, solid architecture, clean code. Launched to 12 signups. Zero paying users. Shut it down.

The postmortem was brutal but clear: I built something nobody needed. I fell in love with the solution before verifying the problem existed.

I'm sharing this because I know I'm not the only developer who's done this. And I want to do something different this time.

I've decided to start with zero code and instead spend time talking to people about what's actually broken in their work. I'm treating customer discovery like a engineering problem: gather data, find patterns, then build.

I'm looking for input from this community:

What task do you do manually every week that you keep thinking "there should be an API for this"?
What existing tool frustrates you so much that you've considered building your own replacement?
If you could wave a magic wand and automate one part of your development workflow, what would it be?

I'm not promoting anything. There's no landing page, no newsletter, no beta list. I'm genuinely trying to find a problem worth solving. If patterns emerge and I build something, I'll document the entire process here.

What problems are you all facing?

Why We Don't Let GPT-4 Parse Financial Intents (And What We Use Instead)

kennedy — Wed, 24 Jun 2026 14:47:02 +0000

I asked GPT-4 to parse "bridge my ETH to Arbitrum" and it returned:

{ "sourceChain": "Ethereum", "destChain": "Arbitrum", "token": "ARB" }

It confused the destination chain with the ARB token. If an agent executed this, it would swap ETH for ARB instead of bridging. That's a $10,000 hallucination.

This isn't a prompt engineering problem. It's a fundamental issue with using probabilistic models for deterministic financial parsing. Here's the system we built to eliminate it entirely.

kawacukennedy / kuberna-labs

Agent Orchestration Platform — Deploy, run, and certify autonomous AI agents that execute cross-chain Web3 tasks. Smart contracts, SDK, backend, and dashboard for AI-powered DeFi automation.

Kuberna Labs

Agent Orchestration Platform — Deploy, run, and certify autonomous AI agents that execute cross-chain Web3 tasks.

⭐️ If you find this project useful, please star it on GitHub! ⭐️

It helps others discover the project and motivates contributors.

📋 Table of Contents

Overview

Kuberna Labs gives AI agents secure execution rails across any blockchain: agents parse natural language intents, make autonomous trading decisions, settle via on-chain escrow, and get post-quantum certified for verifiable reputation.

Target users: Web3 developers and teams who want to deploy autonomous AI agents that can trade, monitor, and execute on any chain without managing LLM infrastructure, blockchain RPCs, or certification pipelines.

✨ What Makes Kuberna Different?

Feature	Kuberna	Others
Natural Language → On-Chain Action	Parse "swap 1 ETH for USDC on Solana" → escrow → execution → certificate	Require manual

…

View on GitHub

The problem with LLMs for structured extraction

LLMs are probabilistic by design. They don't know anything — they predict the most likely token sequence given their training data. For financial intents, this means:

Chain names overlap with token symbols — "Arbitrum" vs "ARB", "Solana" vs "SOL"
Amounts can be ambiguous — "1 ETH" is clear, "send some" is not
Missing chain names — "swap 1 ETH for USDC" doesn't specify the destination chain
Novel phrasing — "bridge my bags over to polygon" needs to resolve to Polygon (MATIC)

Each of these is a recoverable error for a deterministic parser. Each is a potential loss-of-funds event for a probabilistic one.

The cost of hallucination in financial execution is not a bad chatbot response. It's real money moving to the wrong chain.

Our 4-layer approach

We never call GPT-4 first. The LLM is the last resort, not the primary parser.

Layer 1: compromise.js   (zero-dep NLP, offline)    ← 80% of intents
Layer 2: 12 regex patterns (deterministic matching)  ← 5% of intents
Layer 3: GPT-4 fallback   (only when conf < 0.6)     ← 15% of intents
Layer 4: RAG memory        (learns from past parses)  ← ongoing

Layer 1: compromise.js

compromise.js is a zero-dependency NLP library that runs in the browser, Node.js, and Deno. It handles:

Subject-verb-object extraction ("swap ETH for USDC")
Named entity recognition ("Ethereum", "Solana", "Arbitrum")
Number and unit parsing ("1.5 ETH", "500 USDC")

It weighs ~200KB and requires no API key. For well-formed intents, it's sufficient 80% of the time.

import nlp from 'compromise';

function parseWithCompromise(input: string): Intent | null {
  const doc = nlp(input);
  const tokens = doc.match('#Noun+');
  const amounts = doc.numbers().get();
  // ... extract structured intent
}

Layer 2: Regex patterns

For the 5% of intents where compromise.js yields low confidence, we fall through to 12 regex patterns covering common structures:

const PATTERNS = [
  // "swap X for Y on Z"
  /swap\s+(?<amount>\d+\.?\d*)\s+(?<source>\w+)\s+for\s+(?<dest>\w+)\s+on\s+(?<chain>\w+)/i,
  // "bridge X to Y"
  /bridge\s+(?<amount>\d+\.?\d*)\s+(?<token>\w+)\s+to\s+(?<chain>\w+)/i,
  // "send X to Y on Z"
  /send\s+(?<amount>\d+\.?\d*)\s+(?<token>\w+)\s+to\s+(?<chain>\w+)/i,
  // ... 9 more patterns
];

Each pattern maps matched groups to a validated Intent structure. If the mapping contains an unrecognized chain or token, the parse fails safely — no hallucination possible.

Layer 3: GPT-4 fallback

Only when both layers 1 and 2 return confidence < 0.6 do we call GPT-4. The prompt is structured to minimize hallucination:

const prompt = `
Parse the following cross-chain intent into JSON.
Only use chain names from this list: ${VALID_CHAINS.join(', ')}
Only use token symbols from this list: ${VALID_TOKENS.join(', ')}
If any value cannot be determined, set it to null. Do not infer.

Input: "${input}"
Output:`;

The LLM is constrained to a known vocabulary. If it returns a chain name not in VALID_CHAINS, the system rejects the parse. This caught the "Arbitrum" → "ARB" hallucination described above.

Layer 4: RAG memory

Every successful parse (regardless of which layer handled it) is stored in a vector database. Common patterns are promoted to new regex patterns over time.

After 6 months of operation, layer 4 has:

Generated 4 new patterns now handled by layer 2
Increased layer 1 hit rate from 72% to 80%
Reduced LLM fallback from 22% to 15%

Confidence scoring

Each layer assigns a confidence score. We stop at the first layer with score > 0.6.

const { intent, confidence } = await parseIntent('swap 1 ETH for USDC on Solana');

console.log(intent);
// {
//   sourceChain: "solana",
//   sourceToken: "ETH",
//   destToken: "USDC",
//   sourceAmount: "1",
//   confidence: 0.85
// }

Confidence is based on:

How many fields were successfully extracted (4/4 is better than 3/4)
Whether all chain/token names are in the known vocabulary
Pattern match strength (regex exact match > compromise fuzzy match > LLM generation)

If confidence is below 0.6 after all 4 layers, the intent is rejected and the agent is asked to rephrase.

How we tested this

175 tests covering:

Well-formed intents ("swap 1 ETH for USDC on Solana")
Missing chain names ("swap 1 ETH for USDC")
Novel phrasing ("move my bags to polygon")
Deliberately adversarial inputs ("ETH for BTC on Ethereum ethereum ethereum")
Chain/token confusion ("bridge to ARB on Arbitrum")
Mixed case, typos, extra whitespace

Property-based tests using fast-check verify invariants: the parser never returns a chain name not in VALID_CHAINS, never returns a token symbol not in VALID_TOKENS, and never fabricates an amount.

Zero hallucinated chains in production.

When you SHOULD use an LLM

The 4-layer system isn't anti-LLM. It's pro-determinism.

Use an LLM when the input is genuinely novel, the phrasing is ambiguous, or the intent contains information your deterministic layers can't handle. But don't use an LLM as your primary parser for financial inputs.

The LLM is a safety net, not the primary system. Build deterministic layers first. Let the LLM handle edge cases. And always validate the output against a known vocabulary before accepting it.

The parser is MIT licensed and works without any API key: backend/src/services/intentParser.ts

If you've hit similar hallucination problems with LLM-based extraction, I'd love to hear how you solved it in the comments.

Previously in this series: We Built an Open-Source SDK for Cross-Chain AI Agents — Here's What Broke
Next in this series: How We Built a Circuit Breaker for AI Agents That Touch Real Money

We Built an Open-Source SDK for Cross-Chain AI Agents, Here's What Broke

kennedy — Wed, 24 Jun 2026 14:28:31 +0000

It's 3 AM and your AI agent just bridged $500 to a chain you've never heard of.

The logs say "optimal route found." The balance says $0. The agent can't explain why.

This is the problem we spent 6 months solving.

We built Kuberna Labs, an MIT-licensed SDK that gives AI agents secure execution rails across any blockchain. The whole thing is open-source: github.com/kawacukennedy/kuberna-labs

Here's what we actually had to build.

kawacukennedy / kuberna-labs

Agent Orchestration Platform — Deploy, run, and certify autonomous AI agents that execute cross-chain Web3 tasks. Smart contracts, SDK, backend, and dashboard for AI-powered DeFi automation.

Kuberna Labs

Agent Orchestration Platform — Deploy, run, and certify autonomous AI agents that execute cross-chain Web3 tasks.

⭐️ If you find this project useful, please star it on GitHub! ⭐️

It helps others discover the project and motivates contributors.

📋 Table of Contents

Overview

✨ What Makes Kuberna Different?

Feature	Kuberna	Others
Natural Language → On-Chain Action	Parse "swap 1 ETH for USDC on Solana" → escrow → execution → certificate	Require manual

…

View on GitHub

What "agent execution" actually means

Most people think "AI agent" means a chatbot with tool access. That's not what we're building.

An agent that calls an API and an agent that settles a financial transaction are fundamentally different problems. The first is about formatting HTTP requests. The second is about moving value across chains, proving what happened, and resolving disputes when something goes wrong.

Agent execution, in our definition, means:

An agent forms an intent ("swap 1 ETH for USDC on Solana")
That intent is parsed into a structured, verifiable format
Executors compete to fulfill the intent at the best price
An escrow contract holds funds until conditions are met
A TEE attestation proves the agent's decision was made correctly

Every layer above had to be built from scratch. No off-the-shelf solutions existed for open-source agent settlement.

Why intent-based execution is safer than direct wallets

Giving an agent a private key is the obvious approach. And it's terrifying.

If an agent holds a key, that key is accessible wherever the agent runs. A compromised agent means a drained wallet. There's no intermediary, no dispute window, no recourse.

Our architecture inverts this: the agent never holds keys. It posts intents. Executors compete to fulfill those intents. An on-chain escrow contract settles the transaction only when conditions are met.

const sdk = new KubernaSDK({ apiKey: process.env.KUBERNA_API_KEY })

const intent = await sdk.intents.create({
  sourceChain: "ethereum",
  destChain: "solana",
  sourceToken: "ETH",
  destToken: "USDC",
  sourceAmount: "1.0",
})

The agent posts an intent. The SDK handles the rest. No keys, no custody, no single point of failure.

How we stop the intent parser from hallucinating chains

This was the hardest technical problem we solved.

We started with GPT-4 to parse natural language intents. The results were terrifying:

// Input: "bridge my ETH to Arbitrum"
// GPT-4 output:
{ sourceChain: "Ethereum", destChain: "Arbitrum", token: "ARB" }

It confused the destination chain with the ARB token. If an agent executed this parse, it would swap ETH for ARB instead of bridging. That's a $10,000 hallucination.

We built a 4-layer fallback system:

compromise.js — zero-dependency NLP that works fully offline. Handles 80% of intents.
12 regex patterns — matching "X for Y on Z" and variations. Deterministic, no failure mode.
GPT-4 fallback — only when confidence < 0.6 from layers 1 and 2. Activated in ~15% of cases.
RAG memory — learns from past parses. Common patterns are promoted to layer 2 over time.

Each layer assigns a confidence score. We stop at the first layer with score > 0.6.

The result: zero hallucinated chains in production. 175 tests covering every edge case.

What on-chain escrow looks like for AI agents

Trustless settlement requires an escrow contract that handles the agent-specific edge cases:

function assignExecutor(
  bytes32 intentId,
  address executor,
  bytes calldata params
) external nonReentrant onlyAgent(intentId) {
  Escrow storage e = escrows[intentId];
  require(e.status == EscrowStatus.PENDING, 'not pending');
  e.executor = executor;
  e.executorParams = params;
  e.status = EscrowStatus.ASSIGNED;
  emit ExecutorAssigned(intentId, executor, params);
}

The nonReentrant modifier on assignExecutor and raiseDispute prevents reentrancy attacks. Every intent has a dispute window. If the agent disagrees with execution, funds are held pending resolution.

Why TEE attestation matters for provable decisions

An agent's decision trace must be provable. Without attestation, the agent can claim "I don't know what happened" and you have no way to verify.

We run decision-making inside an SGX enclave. Every inference produces a cryptographic receipt:

{
  "intentId": "0xabc...",
  "decision": "executor_selected",
  "executorAddress": "0xdef...",
  "confidence": 0.87,
  "attestation": "sgx://enclave-123/receipt/0x789..."
}

This receipt is stored on-chain. Anyone can verify that the agent made the decision it claims to have made, inside a trusted execution environment, at a specific point in time.

The circuit breaker problem

An agent that can't stop calling a dead API is an agent that burns money.

We implemented a sliding-window circuit breaker around all OpenAI calls:

CLOSED — normal operation
3 failures in 5 minutes → OPEN
30 second probe interval → HALF_OPEN
Probe succeeds → CLOSED
Probe fails → back to OPEN

const circuit = new CircuitBreaker(intentParser, {
  threshold: 3,
  windowMs: 300_000,
  probeIntervalMs: 30_000,
});

const result = await circuit.call('swap 1 ETH for USDC on Solana');

When the circuit is open, the agent falls back to the local compromise.js parser. No API call needed. The agent still works — it just makes simpler decisions.

Graceful degradation > perfect uptime.

What broke (the honest part)

Not everything went smoothly. Here's what we got wrong:

Math.sin() as a price oracle. Our first "market data provider" used Math.sin() to generate fake price data. It was a placeholder that somehow made it to staging. A real API integration would have caught this earlier.

Direct wallet integration. Our first design gave agents access to a wallet. We reversed this after a close call in testing. The intent-based architecture is harder to build but fundamentally safer.

No circuit breaker. We deployed the first version without rate limiting on API calls. The agent called a dead OpenAI endpoint 47 times before we noticed. Each call cost money. Each call returned nothing.

Intent parser hallucinating chains. The GPT-4 hallucination problem above cost us a week of refactoring. The 4-layer system was born from failure.

Where we're going next

zkTLS integration — proving agent decisions without revealing sensitive data
Solana support — the first non-EVM chain in the execution layer
NEAR Intents — cross-chain settlement using NEAR's intent infrastructure

The whole thing is MIT. 175 tests, all green. If you've fought with cross-chain settlement and won (or lost), I'd love to hear about it in the comments. PRs very welcome.

Next in this series: Why We Don't Let GPT-4 Parse Financial Intents (And What We Use Instead)

Building Autonomous Cross-Chain AI Agents with Kuberna Labs

kennedy — Sun, 15 Mar 2026 20:13:27 +0000

If you've ever tried to build an AI agent that can actually do something on-chain—like swap tokens, monitor a protocol, or execute a trade across chains—you know the pain. You need to manage private keys, estimate gas, handle failed transactions, and orchestrate complex cross-chain flows. It's brittle, time-consuming, and error-prone.

That's why we built Kuberna Labs: an open-source SDK and infrastructure that abstracts away the complexity of cross-chain execution for AI agents.

The Stack

Our architecture is designed to take a high-level intent (e.g., "Swap 1 ETH to USDC on Solana") and execute it securely, with cryptographic guarantees. Here's how it works:

LLM / NLP Engine – Parses natural language into structured tasks.
Kuberna SDK – Provides a unified API for agent creation, intent submission, and execution.
Execution Layer:
- TEEs (Phala, Marlin) – Run agent logic in trusted enclaves with remote attestation.
- zkTLS (Reclaim, zkPass) – Fetch verified Web2 data without exposing credentials.
- Intent Router (ERC-7683) – Broadcasts intents to a decentralized solver network.
Solver Network – Agents compete to fulfill intents, with funds secured in escrow contracts.

Why This Matters

Most AI agents today are just chatbots—they can't actually transact value. Kuberna turns them into autonomous economic actors. Imagine an agent that:

Monitors a DeFi protocol's TVL and alerts you on Discord.
Executes arbitrage across DEXes when profitable.
Proves your bank balance on-chain without revealing the number (via zkTLS).

Get Started in 2 Minutes

npm install @kuberna/sdk

import { KubernaSDK } from '@kuberna/sdk';

const sdk = new KubernaSDK({ apiKey: 'YOUR_API_KEY' });
const agent = await sdk.createAgent({
  name: 'YieldOptimizer',
  framework: 'ElizaOS',
});
console.log(`Agent ${agent.id} is live!`);

The SDK handles all the hard stuff—wallet management, gas estimation, intent routing—so you can focus on your agent's logic.

Open Source & Community

Kuberna Labs is 100% open-source and built in public. We're based in Kigali, Rwanda, and we're on a mission to become the operating system for the agentic economy.

👉 GitHub Repo

👉 Discord

We'd love your contributions, ideas, and stars. Let's build the future of autonomous agents together.

Sunder: The Open‑Source AI Coding Assistant That Translates, Explains, and Pairs With You

kennedy — Thu, 12 Feb 2026 09:00:17 +0000

The Problem

Every developer knows the drill:

You find a brilliant Python snippet, but your project is in JavaScript.
You want a second pair of eyes, but scheduling a code review takes days.
Copilot helps, but it’s proprietary, doesn’t explain why, and can’t translate.

Sunder fixes all of that; and it’s now open source.

What Is Sunder?

Sunder is an AI‑powered collaborative platform for code snippets. Think GitHub Gists meets Figma meets Gemini.

With Sunder you can:

Save & discover snippets across 50+ languages
Translate code between languages with functional equivalence
Pair program with an AI that learns your style
Real‑time collaborate on snippets with cursors, chat, and video
Get explanations and refactoring suggestions on demand

All inside a beautiful Next.js + Tailwind UI.

Why Open Source?

We believe developer tools should be transparent, community‑owned, and accessible to everyone.

By open‑sourcing Sunder we’re saying:

You shouldn’t need a corporate budget to have an AI pair programmer.

We also want to build the best AI‑first coding platform – and that can only happen with contributions from developers like you.

Try It in 60 Seconds

git clone https://github.com/kawacukennedy/sunder
cd sunder
./scripts/setup.sh

That’s it. Docker Compose spins up PostgreSQL, Redis, and a mock AI server – you don’t even need a Gemini API key.

Then open http://localhost:3000 and start exploring.

🧩 What Needs Help?

We’ve curated 20+ “good first issues” with detailed instructions and mentors.

Area	Example Issue
🎨 Frontend (React)	Add syntax highlighting for Rust
⚙️ Backend (Node)	Optimize snippet search with trigram indexes
🧠 AI (Gemini)	Improve translation accuracy for Go → TypeScript
📚 Docs	Write a tutorial for real‑time collaboration

👉 Browse good first issues →

💬 Join Our Community

We’re on Discord; ask questions, share what you build, and meet other contributors.

One Last Thing

If you believe AI tools should be open and collaborative:

Star the repo – it helps others find us
Share this post with a friend who loves AI
Pick an issue and make your first contribution today

Let’s build the future of coding – together.

Sunder on GitHub: github.com/kawacukennedy/sunder

Contact: Email
Twitter: @Arnaud_Kennedy

I’m Building a High-Signal Discord for Developers Who Actually Want to Build (Not Another Dead Server)

kennedy — Thu, 08 Jan 2026 18:44:17 +0000

Most developer Discord servers fail for the same reasons:

Too many channels
No structure
No onboarding
Everyone talks, nobody builds

So I decided to build something different.

I just launched a Developer Discord Community designed around clarity, progression, and real collaboration.

What makes this server different

This is not a “drop a link and disappear” Discord.

We’ve designed it with:

Structured onboarding (Beginner, Intermediate, Advanced)
Clean channel UX (you only see what’s relevant to you)
Focused help channels (no noise, no spam)
Project collaboration (ideas → teams → execution)
A new Web3 channel for serious discussions around blockchain, smart contracts, and decentralized apps

Who this is for

Developers who want to learn properly
Developers who want to build real projects
Developers who want feedback, not fluff
Developers who want a community that respects their time

Stacks include:
Frontend, Backend, Mobile, AI/ML, DevOps — and now Web3.

What you’ll actually do inside

Ask and answer real technical questions
Get code reviews
Collaborate on projects
Share resources that matter
Learn from developers at different levels

Join here

👉 Discord Server

If you’re tired of low-signal communities and want a place that feels intentional and well-run, you’re welcome.

Let’s build something meaningful.

I Built 12 Projects In 12 Days… and Almost Lost My Mind 😭💻

kennedy — Tue, 02 Dec 2025 11:51:56 +0000

If you’ve ever said “I’ll start coding seriously tomorrow”,
and then tomorrow becomes next week… and next week becomes
“after this YouTube video”…

Yeah. Same.

I wasn’t a “perfect” coder — I wasn’t even a consistent coder.

I was more like:

Start a project → Get excited → Get stuck → Open TikTok → Never return.

But deep inside, something had to change.

So I did something… questionable, bold, and slightly unhinged:
I challenged myself to build 12 projects in 12 days.

Did I suffer? Yes.
Did I improve? More than I expected.
Would I do it again?

…Let’s not talk about that yet.

😤 Days 1–3: “I Am Him” Energy

I started small — a little too small.

A weather app
A mini Pac-Man style game
A simple note app

I felt unstoppable. I was coding like I had a personal sponsorship from Red Bull.

😵 Days 4–6: Bug-Induced Hallucinations

This is where things… shifted.

You know those bugs that exist purely to test your patience?

Like when a button doesn’t work because you spelled onclick as onlcik
for 2 hours straight.

At one point, I opened my console and it opened back at me.

😭 Days 7–9: The Existential Dread Arc

Halfway through, I questioned EVERYTHING:

My skills
My sanity
My life decisions
Whether computers were even meant for humans

But each time I considered giving up, a tiny voice whispered:

“Bro, you already tweeted about this challenge. You can’t embarrass yourself now.”

So I kept going.

🤯 Days 10–12: Final Boss Mode

Something weird happened:
I started coding… calmly?

My debugging got faster.
My problem-solving improved.
I didn’t cry (as much).

By Day 12, I pushed the last project, closed VS Code, and just sat there.

I felt peace.
Or maybe burnout. Hard to tell.

💡 What I Learned (that school doesn’t teach you)

✔ Consistency > Motivation

Motivation comes and goes.
Consistency stays — especially when your pride is on the line.

✔ Projects teach faster than tutorials

You can’t “tutorial” your way into mastery.
You need to build stuff. Break stuff. Fix stuff. Cry a bit.

✔ Your future self will thank you

Even if your current self is suffering and eating cold noodles at 2 AM.

🔥 Final Thoughts

This challenge didn’t turn me into a genius overnight.

But it changed my mindset.

If you're a beginner reading this, let me tell you:
You can become a great developer — just don’t quit when it gets hard.

Start small. Build consistently.
And maybe don’t do 12 projects in 12 days unless you're mentally prepared.

(You’re probably not. I wasn’t.)

❤️ If You Enjoyed This

Leave a comment!
Share the article!
Tell me if you want the “12 Projects in 12 Days” full breakdown + code.

I might drop it.
After I recover.

👨‍💻 Welcome to the Life of a Developer

kennedy — Mon, 24 Nov 2025 15:48:33 +0000

Hey there! If you’ve ever wondered what it’s like to be a software developer, pull up a chair, grab some coffee, and brace yourself.

My Daily Routine

9:00 AM – Open laptop and stare at code for 5 minutes wondering if I'm alive.
9:05 AM – Realize I have no idea what I’m doing, Google everything.
11:00 AM – Solve a bug that shouldn’t have existed in the first place.
2:00 PM – Automate a task that takes 2 minutes, just to feel like a wizard.
4:00 PM – Remember I skipped lunch. Eat instant noodles.
6:00 PM – Code review: Cry silently while pretending to understand your teammate’s code.
2:00 AM – Push a fix to production. Panic internally. Celebrate externally. 🎉

Developer Truths

Debugging is like being a detective in a crime movie where you are also the murderer.
Stack Overflow is basically my second home.
Coffee: not a drink, a lifestyle.
Code Comments: If future-me can’t understand this, no one can.

Why I Love Development

Because at the end of the day, I build things that make life easier, solve problems, and occasionally cause chaos in production. And somehow, people pay me for it. 💸

"Talk is cheap. Show me the code." – Linus Torvalds

PS: If you read this and laughed (or cried), star this repo. You know, for moral support. Star it here! ⭐

🚀 Autonomous Process Auditor (APA)

kennedy — Sat, 22 Nov 2025 22:43:08 +0000

AI that doesn’t assist — it works.

I just built Autonomous Process Auditor (APA) for the Agentic AI Hackathon (IBM watsonx Orchestrate) — and it might be the most useful AI agent I’ve ever created.

Audits suck.
They’re slow, manual, error-prone, and nobody wants to do them.

So I built an AI agent that does 100% of the auditing work automatically.

🔥 What APA Does

✅ Automates end-to-end auditing

No more spreadsheets. No more human mistakes.

🤖 Validates workflows across tools

Slack, Jira, Notion, Gmail, internal systems — APA checks everything.

📊 Detects anomalies in real time

Human reviewers catch mistakes late. AI catches them instantly.

⚡ Generates audit trails automatically

Every action. Every timestamp. Fully traceable & exportable.

🔗 Uses IBM watsonx Orchestrate to chain skills

APA can:

Pull data
Analyze patterns
Flag issues
Write reports
Notify teams
Log results —all without human intervention.

🧠 Why This Matters

Most “AI assistants” still need humans for everything important.
APA isn’t an assistant.
It’s an Agentic AI system that completes tasks autonomously from start to finish.

This is the future of work.
Not chatbots — agents that handle entire workflows.

🏆 If this doesn’t win the hackathon…

…then maybe I need to build an Autonomous Judge Auditor too 😤🔥

💬 What do you think?

Would you trust an AI agent to run audits at your company?
Or is this too much automation?

Let’s talk 👇

🚀 The Unexpected Lesson That Finally Made Me a Better Developer

kennedy — Thu, 20 Nov 2025 06:44:04 +0000

Hi everyone 👋

I’ve been building things on the internet for a few years now. Some projects failed quietly, some did well, and some never escaped the "idea in my notes app" stage.

But a few weeks ago, something strange happened. I hit a wall.

Not the typical "debugging until 3am" wall, I’m talking about that moment where you open your laptop… and just stare. Nothing feels exciting. No idea feels good enough. You keep scrolling, comparing yourself to devs shipping insane stuff every other week.

And I realized something:

I wasn’t stuck because I lacked skills. I was stuck because I forgot why I code.

🌱 The Moment Everything Shifted

I was working on a side project I was really excited about. But somewhere along the way, I started optimizing the wrong things:

Reading 10 articles before writing a single line of code
Trying to make every feature “startup-worthy”
Refactoring code that didn’t even exist yet
Watching more tutorials than actually building

One night, instead of coding, I shut everything down and took a walk. No headphones. No screens.

And I asked myself a simple question:

"What tiny thing can I build that solves a real problem I personally feel?"

Not something impressive. Not something viral.

Just something useful. For me.

That question changed everything.

⚡ I Built Something Small, And It Completely Reignited My Momentum

The next morning I built a tiny tool to automate something I did almost daily.

Nothing fancy.

No authentication. No animations. No pixel-perfect UI.

But for the first time in months, I shipped something.

And that tiny win made me feel something I hadn’t felt in a while:

Momentum.

🎯 The Real Secret to Leveling Up as a Developer

Here’s the thing nobody tells you:

You don’t grow from consuming. You grow from creating.

Every dev you admire learned this the hard way.

They didn’t magically know everything before they started.

They built things they weren’t ready for.

They made mistakes.

They Googled everything.

They broke production (more than once).

And they kept going.

🧨 Why Your Next Project Should Be Small, Imperfect, and Personal

If you’re feeling stuck too, try this:

✔️ Build something just for yourself

Not the world. Not investors. Not dev influencers. You.

✔️ Limit yourself to one feature

No feature creep. No perfection.

✔️ Ship it in 48 hours

Because constraints create creativity.

✔️ Share what you learned

That’s the part most people skip — but it’s where the growth really happens.

❤️ This Is Your Reminder

You're not behind.
You're not late.
You're not supposed to know everything.

You just have to start. Even if it’s small. Even if it's imperfect. Even if it’s a little messy.

Your future self will thank you.

🔥 Before You Go

If you’re reading this and it resonated, drop a comment:

What’s the small project you want to ship this week?

Let’s hype each other up and build cool stuff together.

Thanks for reading 💙

If this helped you, feel free to follow me — I share real, honest content about coding, learning, and building things that matter.

I Built a “Useless” App at 2 AM… And People Actually Loved It 😳

kennedy — Mon, 17 Nov 2025 19:32:05 +0000

Late one night, fueled by too much coffee and existential dread about my career, I decided to build an app.

Was it perfect? Nope.

Was it pretty? Definitely not.

Did I almost delete it multiple times? Absolutely.

But here’s the insane part: when I shared it with a few friends, they actually started using it. And that’s when I realized:

You don’t need to build a masterpiece. You just need to build something that works.

5 Brutal Truths About Shipping Stuff No One Asked For

Your first version will be ugly.

Like, really ugly. And that’s okay. People don’t care if it’s polished—they care if it solves a problem.
Tiny problems are gold mines.

That small frustration you’ve learned to ignore? That’s your next app idea. Seriously.
Feedback > Planning. Always.

You can spend weeks designing the “perfect” app… or 3 hours getting real feedback that actually matters. Hint: choose the latter.
Share your mess.

Don’t wait for the “finished product.” People love seeing progress, learning curves, and even failures. Authenticity = engagement.
Celebrate weird wins.

That one person who screenshots your app and says “This actually helps me”? That’s proof your work matters. Pat yourself on the back. You earned it.

Here’s the kicker: that midnight project that I thought was useless is now being used by a small community.

And the lesson?

You don’t have to wait for inspiration. You don’t have to wait for perfection. You just have to start.

💬 Your turn: Have you ever built something “just for fun” that actually worked? Or failed gloriously? Drop your story in the comments. Let’s normalize messy wins.

🔁 Pro tip: Share this with a dev friend who’s stuck on a side project. You might be the push they need to finally ship.

🚀 Follow Me on X (Twitter) — Let’s Build Something Insane Together

kennedy — Mon, 17 Nov 2025 12:09:10 +0000

Hey Dev Community! 👋

I'm on a mission to build, ship, and share everything I learn in AI, Web Development, Blockchain, Growth Hacking, and Indie Hacking — all in public.

If you're obsessed with:

⚡ Insanely practical coding tutorials
🤖 AI tools, prompts, and workflows
🛠️ Real-life projects built from scratch
🔥 Growth strategies for devs and creators
💼 Shipping ideas fast (and actually finishing them)

Then you’re going to love what I drop on X (Twitter) every single day.

🧠 What You’ll Get on My X Feed

1. Actionable Dev Tips

No fluff. Just real examples, code snippets, and things you can implement today.

2. Public Building

I share everything I’m working on — wins, mistakes, failures, breakthroughs.

3. Viral-Level AI Prompts

Prompts for devs, designers, marketers, founders.

4. Mini Deep-Dives

On frontend, backend, full-stack architecture, and smarter workflows.

5. Motivation for Builders

Because dev burnout is real.

🔥 Why Follow Me?

Because I'm not just tweeting — I'm designing content to make you level up fast.

I break down:

How to think like a developer
How to move faster as a builder
How to turn simple ideas into real projects
How to use AI to supercharge your workflow

All in 30–180 second reads.

💎 Bonus: I Interact With My Followers

Ask a question? I reply.
Need help on a project? I jump in.
Need a custom prompt? I create one.

I’m building a community of sharp developers, indie hackers, and technical creatives.

🎯 My X Content Strategy (aka Why This Will Be Worth Your Follow)

🟦 High-value threads

🟪 Memes + humor to keep it fun

🟩 Quick tutorials

🟥 Hot takes (that spark discussions)

🟧 Live project updates

🟨 Community challenges

This isn’t a typical "follow me" pitch. This is an invite to a high-signal feed.

🚀 Follow Me on X

👉 https://x.com/Arnaud_Kennedy

⭐ If You Found This Inspiring

Drop a ❤️ or leave a comment.

Let’s grow together.
Let’s build together.
Let’s win together.

— Kennedy