A year and a half ago, I wasn't trying to build an AI company. I was building a small social platform called spritex-social — nothing fancy, just a side project a handful of friends were testing with me. No grand plan, no investors, no roadmap beyond "let's see if people like this." At some point, users started asking the same basic questions over and over: how do I change my profile, where's this setting, how does that feature work. Instead of writing endless documentation, I thought — why not just let AI answer this? So I wired up Google's Gemini API through Google AI Studio, built a small Retrieval-Augmented Generation (RAG) system, and gave it context about the platform. It was supposed to be a support chatbot. Nothing more. That's not how it went. I found myself spending more time improving the chatbot than improving the actual social app. Every small upgrade made me ask another question: could it remember conversations? Could it use tools? Could it search the web? Could it do things instead of just answering questions? The more I asked, the less interested I became in the social platform I was supposed to be building. Eventually I had to admit it to myself: I wasn't building spritex-social anymore. I was building something else entirely. So I stopped. Not because the project failed — because my attention had already moved somewhere else, and I finally stopped pretending otherwise. That "somewhere else" became RexiO — a Bangla-first AI platform I've been building solo ever since: my own orchestration layer, an intent classifier, 30+ tools, model routing across providers, and eventually our own fine-tuned models trained from scratch on borrowed Colab GPUs. RexiO went public on July 10, 2026. This chatbot pivot is just one chapter of a much longer story — one that actually starts on a Nokia button phone, ২ টাকা data packs, and a ৳20 freelance job that became my first line of code in production. I wrote the whole thing down, unfiltered — the rewrites, the 12-hour

Stop Writing Prompt Strings: Meet PromptForge Core As AI becomes part of modern applications, prompts are no longer just strings—they're becoming part of your codebase . Yet most of us still write prompts like this: const prompt = " You are a helpful assistant. \n " + " Summarize the following text. \n " + " Return the output as JSON. \n " + " Keep it concise. \n " + " Use simple language. " ; This works... Until your project grows. The Problem As prompts become larger, they quickly become difficult to maintain. You start dealing with: ❌ Giant string templates ❌ Copy-pasted prompts ❌ Missing variables ❌ Inconsistent formatting ❌ Provider-specific implementations ❌ Difficult debugging Unlike your application code, your prompts have: No structure No validation No type safety What if prompts were treated like code? That's exactly why I built PromptForge Core . PromptForge is an open-source TypeScript toolkit for building production-ready prompts using a clean, structured API. Instead of writing strings... const prompt = " You are... " You write import { pf } from " @promptforgee/core " ; const summarize = pf . define ({ input : z . object ({ text : z . string (), }), output : z . object ({ summary : z . string (), }), messages : ({ text }) => [ pf . system ` You are an expert summarizer. ` , pf . user ` Summarize: ${ text } ` , ], }); Much easier to read. Much easier to maintain. Features PromptForge focuses on developer experience. ✅ Type-safe prompt definitions ✅ Structured prompt composition ✅ Prompt compilation ✅ Validation ✅ Provider-agnostic architecture ✅ Reusable prompt blocks ✅ Modern TypeScript API Compile Once, Use Anywhere Instead of maintaining different formats for every provider... PromptForge compiles your prompt into provider-specific formats. Prompt Definition ↓ Prompt Compiler ↓ OpenAI Anthropic Gemini Ollama Write once. Compile anywhere. Composable Prompts Large AI applications usually repeat the same instructions. With PromptForge you can compose p

Last month I watched Cursor confidently rename a field across an entire API, commit it, and open a PR. Clean diff, tests green, looked great. It had also just broken a mobile client and a partner integration that were still reading the old field name — and neither Cursor nor I noticed until much later. That's the thing about AI coding agents and APIs: they're fast, they're fearless, and they have zero awareness of your API contract . An agent will drop an endpoint, make a request field required, or change a response type without any sense that a real consumer out there depends on the old shape. The code compiles. Your tests pass (your tests — not the consumer's). The breakage is completely silent until someone downstream feels it, usually in production, usually from an angry message rather than a failing build. We keep giving agents more power to write API changes and nothing to tell them whether a change is safe to ship . So I built that missing piece as an MCP server. The gap: there's no "is this safe?" step in the loop Think about how you'd catch this manually. You'd diff the old and new OpenAPI spec, look for removed endpoints, removed response fields, tightened request contracts, enum narrowing — the classic breaking changes — and decide whether it's safe to merge or whether you need a version bump and a heads-up to consumers. An agent never does that. It has the code in context, not the contract implications . And "did I just break a consumer?" is exactly the kind of question it should be asking before it hands you a diff. Enter MCP If you haven't used it yet: the Model Context Protocol is a standard way to give AI agents tools — little capabilities they can call. Claude, Cursor, and others all speak it. Instead of the agent guessing, it can call a tool and get a real answer. So the fix is simple to state: give the agent a tool that answers "is this API change safe to ship to my consumers?" — and have it call that before it proposes the change. That's the hero

While building a Computer-Based Testing (CBT) platform, I ran into an unexpected problem. Creating mathematics and chemistry questions wasn't nearly as straightforward as I expected. Although there are many excellent editors and open-source libraries available, I couldn't find one that brought everything together in a way that was simple, lightweight, and designed specifically for CBT systems. Instead of building everything from scratch, I took a different approach. I combined several powerful open-source technologies into a single editor that focuses on one job—making it easy to create mathematics and chemistry content for online examinations. The result is CBT Editor, a free and open-source equation editor built for developers, schools, and educational platforms. It supports common mathematical expressions, chemistry notation, scientific symbols, fractions, superscripts, subscripts, and more, while remaining easy to integrate into existing projects. This project isn't meant to replace the fantastic libraries that already exist. In fact, it depends on them. The goal is to provide a clean, unified experience so developers don't have to spend hours combining multiple tools just to support technical examination questions. If you're building a CBT platform, an online examination system, or any educational application that requires mathematics and chemistry editing, I'd love for you to give CBT Editor a try and share your feedback. 🔗 Live Demo: https://holygist.github.io/cbt-editor/ Open-source software grows through collaboration. If you find the project useful, feel free to contribute, report issues, suggest improvements, or simply share it with other developers.

The Complete TypeScript Mastery Guide Navneet Verma Navneet Verma Navneet Verma Follow Jul 10 The Complete TypeScript Mastery Guide # typescript # webdev # systemdesign # tutorial 5 reactions Add Comment 54 min read

This is a submission for Weekend Challenge: Passion Edition What I Built I built PitchPassion AI , a web application that transforms text-based football match narratives into informative player performance visualizations using AI. The goal is to help fans quickly understand statistics without having to read lengthy reports. Demo I will include a video demo link below. Video Demo: Video File Code Back-End: Repository Back End Front-End: Repository Front End How I Built It Tech Stack: React for front end, Flask for back end, Google Gemini API. AI Integration: The biggest challenge in sports data analysis is the unstructured nature of the data sources. Match reports typically consist of lengthy paragraphs written by journalists or narratives from spectators. While humans can easily read them, computers (databases) cannot directly process such text into charts or graphs. This is where I utilize the Google Gemini API as a data extraction engine: Natural Language Processing (NLP): Gemini reads the match narrative to comprehend the context—identifying the players involved, the actions performed (goals, assists, tackles), and the quality of those actions. Structured Transformation: I provide specific instructions (prompts) to the model so that it not only understands the text but also transforms it into a JSON format. Data Cleaning: Since AI sometimes includes conversational text in its output, I implemented middleware in Flask to clean the response and ensure that only pure JSON data enters my application. Problem solving: API Stability Issues (Error 503) During development, I frequently encountered 503 Unavailable responses from the Google Gemini API. This was caused by traffic spikes on the server side. Solution: I didn't let the application simply fail. I implemented a retry strategy in my Flask backend. If the API failed due to server load, the system would automatically wait for 2 seconds and retry up to three times before returning an error message to the user. This

Learn TypeScript From First Principles to Senior/Staff-Level Production Engineering If you searched for how to learn TypeScript properly — not just the syntax, but the thinking behind it — this guide is built for that. Most TypeScript tutorials stop at "here's an interface, here's a generic." This one goes further: it's a single, exhaustive TypeScript tutorial and reference that walks through the type system, object-oriented programming, generics, async programming, design patterns, SOLID and DRY principles, error handling, testing, and the tooling that real production teams run in CI — the same TypeScript best practices used at top-tier engineering organizations. Whether you're a beginner looking for a structured TypeScript for beginners path, or an experienced JavaScript developer making the jump to advanced TypeScript and system design, you can read this end to end or jump straight to the section you need using the linked table of contents below. Table of Contents 1. Introduction — What Is TypeScript & Why It Exists 2. Installation, Setup & tsconfig.json Deep Dive 3. Variables & the Complete Type System 4. Functions — Every Form, Overloads, this , and Best Practices 5. Arrays & Tuples 6. Objects & Type Aliases 7. Interfaces 8. Enums & Literal Types 9. Union, Intersection & Discriminated Unions 10. Type Narrowing, Assertions & Type Guards 11. Classes & Object-Oriented Programming 12. Generics — Basic to Advanced 13. Modules, Namespaces & Project Structure 14. Asynchronous Programming — Event Loop to Production Patterns 15. Advanced/Utility Types & the Type-Level Programming Toolkit 16. Design Patterns in TypeScript 17. SOLID, DRY, KISS, YAGNI — Principles Applied With Real TS Code 18. Error Handling Strategies 19. Testing TypeScript 20. Tooling, Linting, Build Systems & CI/CD for Production TS 21. Performance, Compiler Internals & Scaling Large Codebases 22. Interview Cheat Sheet (Expanded) 23. One-Page Quick Revision Sheet 1. Introduction — What Is TypeScript & W

Here we're going to cover the installation steps of Browsers in Linux - specifically, Debian GNU/Linux . We're covering the procedural steps for this in Debian Testing (Forkey), which is already beginning the gleanings of what will become Debian 14. At the time of writing,the current kernel version is 7.0.13+deb14-amd64. Daily drivers will likely be along the lines of Vivaldi, Firefox, Lagrange, and Brave Browser, and in no particular order. Any others will be mostly for particular reasons like, testing, curiosity, Etc., but some specialized products like the Tor browser, which focus on privacy are also covered. This list is by no means complete, but there's a bunch of them we cover, so let's jump right in! I can haz #Cheezburgerz? 🍔 🍟 Well, let's see... First up is the first rate and fully featured Vivaldi, built on top of the open source Chromium, as are so many others in this list. Vivaldi Manual setup of the Vivaldi Linux repos - According to their website, "you no longer need to do this. After downloading a Linux package and installing it our Linux update repositories will be configured automatically for you to receive updates." That's awfully nice, so visit the download page above and get the .deb package: ~# mkdir -pv /usr/local/packages/vivaldi ; cd /usr/local/packages/vivaldi ~# wget https://downloads.vivaldi.com/stable/vivaldi-stable_8.1.4087.48-1_amd64.deb ~# apt install ./vivaldi * .deb That's it! You're ready to go now. Next up... Firefox ~# apt update && apt install firefox-esr There's none of this messing about anymore with softforks and trying to remember their names...'IceCat?', 'IceWeasel?'. The Trademark issues over branding have been resolved (and that's a good thing). The one thing you might want to look into is SeaMonkey , which combines the Browser with an email client (like Thunderbird), an RSS Reader, IRC client, and a few other goodies. Brave Browser ~# apt install curl ~# curl -fsSLo /usr/share/keyrings/brave-browser-archive-keyring.gpg ht

Sadly, we don't think aliens were involved in this particular space balls incident.

How I Supervise Three Engineering Workflows at Once Three Workflows, One Operator Right now, I have three engineering workflows open. One is under council review. Four AI roles are challenging an architectural proposal, and I will need to decide which objections actually change the plan. The second is already in implementation. That one does not need me at the moment. The specification is approved, the boundaries are clear, and the executor can keep moving. The third has come back from audit. The findings are valid, but corrective work is paused. A remediation plan exists, and someone other than the executor needs to review it before any more code changes. This is the part that still feels new: I can move between all three without reopening old chats and rebuilding the story in my head. A few months ago, even one workflow could take most of my attention. I carried context between every stage: rewriting role prompts, moving decisions between conversations, tracking the current document, and turning audit findings into the next round of work. The AI council itself was already useful. It produced strong reasoning and exposed assumptions I would probably have missed. But I was still the glue around it. The council improved the decisions. The system around it made those decisions easier to carry into implementation, audit, and correction without losing control. Conversations Were No Longer the Workflow The main change was simple to describe: I stopped treating the workflow as a series of conversations. Chats are good for thinking. They are not a good place to keep authority. Before this change, a decision might exist somewhere in a long discussion. The next agent had to interpret it, and I had to remember whether it was final, provisional, or already replaced. Now the state of the work lives in a small set of artifacts. Evidence becomes a source-grounded brief. Decisions become an approved specification. The specification becomes bounded implementation. The implementatio

I have a confession to make. When I first saw that Tether—the behemoth behind the $110 billion USDT stablecoin—was the primary financial backer of Holepunch, Keet, and the Bare JavaScript runtime, my brain short-circuited. I struggled with the cognitive dissonance. Why? Because if you have ever written a smart contract that interacts with USDT on Ethereum Mainnet, you know it is an absolute nightmare. Before we can talk about Tether’s brilliant vision for a decentralized, serverless future, we have to talk about the trauma they inflicted on a generation of Solidity developers. 1. The Original Sin: USDT is not actually an ERC-20 When you are deep in protocol-level engineering, you rely on standards. EIP-20 explicitly states that a token's transfer and transferFrom functions must return a boolean value to indicate success or failure. // The standard EIP-20 Interface interface IERC20 { function transfer(address to, uint256 amount) external returns (bool); } Tether completely ignored this. When they deployed the USDT contract, they omitted the return value entirely. Their functions return void. // The actual USDT Mainnet Implementation (simplified) function transfer ( address to , uint value ) public { // ... logic ... // Notice: No return statement. } If you blindly write a vault or a swap contract using the standard IERC20 interface to move USDT, your transaction will seamlessly execute the logic, move the funds, and then violently revert at the very last microsecond. Why? Because modern Solidity uses a strict ABI decoder. When your contract calls USDT.transfer(), the EVM executes a low-level CALL. When the call finishes, Solidity checks the RETURNDATASIZE. Since it expects a bool (32 bytes), but USDT returns absolutely nothing (0 bytes), the decoder panics and reverts the entire transaction. For years, the only way to build DeFi safely with USDT has been to wrap it in OpenZeppelin's SafeERC20 library, which uses low-level assembly to explicitly check the return data

Hello, I'm Maneshwar. I'm building git-lrc, a Micro AI code reviewer that runs on every commit. It is free and source-available on Github. Star git-lrc to help devs discover the project. Do give it a try and share your feedback. You've been using the terminal for months/ years. Maybe you cd into a folder, ls around, run your script, and call it a day. That's fine. That's like knowing how to boil water and calling yourself a chef. But the terminal has layers . It's basically an onion that occasionally makes you cry, usually around 12 AM when a script fails silently and you have no idea why. So grab your coffee and let's talk about the command line tricks that actually make your life better. Not the "did you know ls -la shows hidden files" tier tips. Your Terminal Has A Memory. Use It. Most devs mash the up arrow like it's 2007 and they're trying to beat a Flash game. Stop that. Press ctrl-r instead. It searches your command history live. Type a few letters, it finds the last matching command. Press ctrl-r again to cycle back further. Found it? Hit Enter to run it, or the right arrow to drop it into your prompt so you can edit it first. ctrl-r ( reverse-i-search ) ` docker run ` : docker run -it --rm -v $( pwd ) :/app node:20 bash Pair this with ctrl-w (delete last word) and ctrl-u (nuke the line back to the cursor) and you'll start editing commands like you're speedrunning a text adventure. And if you're the type who types a whole essay of a command and then realizes you forgot something at the start, ctrl-a jumps to the beginning of the line and ctrl-e jumps to the end. No more holding the left arrow key like it owes you money. Pro tip: if you're a TUI fan and ctrl-r's default search feels a bit flat, check out McFly xargs Is The Friend Who Actually Shows Up Pipes ( | ) are great. They pass output from one command into another. But sometimes you don't want to pass output as input , you want to pass it as arguments . That's where xargs comes in, and once you get it,

Two months ago I picked up a ticket that looked routine: a job that reads mailbox data from Microsoft 365 through EWS, running fine for over a year, started failing on a subset of mailboxes in one tenant. Same app registration, same code path, same service account. The error in the logs pointed at throttling, so that's where the admin had already spent three days looking. Wrong direction. The actual cause had nothing to do with throttling budgets. This mix-up happens constantly right now, and it's worth understanding why, because the fix for one problem does nothing for the other, and chasing the wrong one wastes days. TL;DR: if your EWS failures don't scale with request volume, stop tuning throttling and go check your Application Access Policy scope groups instead. What EWS throttling actually looks like Exchange Online throttles EWS the same way it always has: budget-based. Every account gets a policy (the default is EwsDefaultThrottlingPolicy , but plenty of tenants layer custom ones on top) that tracks a slowly-refilling budget rather than a simple call count. When you overspend it, you get back a 503 or 429 with an X-MS-Diagnostics header telling you which budget got exhausted, usually the connection count or the concurrent-request limit. The tell for real throttling is consistency. It scales with load, correlates with concurrency and batch size, and clears up within minutes once you back off. If you graph failure rate against request volume, you'll see a clean relationship. If you double your batch size, failures increase. If you throttle yourself proactively (respecting Retry-After , staying under EWSFindCountLimit for FindItem calls), it mostly goes away. That correlation is the whole diagnostic test. If your failures don't scale with volume, you're not looking at a throttling problem, no matter what the error message on the surface says. What actually changed Over the past year or so, Microsoft tightened enforcement in two places that both produce errors ea

Turn NotebookLM into a complete research workflow Discussion | Link