With ideas and project specs scattered across platforms like Notion while actual tasks live in GitHub, keeping them in sync is constant manual overhead—how do you bridge this gap without your PM tools and repos becoming a mess? submitted by /u/asifdotpy [link] [留言]
Google seems to be testing a new feature that will take you to AI Mode by default when you do a search in Chrome.
I got really tired, as a human, of parsing the standard marketing heavy web we have today. I've always loved the simplicity of gopher and gemini web. Recently I found myself manually adding `/llm.txt` to most websites I visit because I find the content for LLMs strait to the point and clear. The only annoyance is web browsers like chrome do not render the markdown. So could the AI revolution actually fix the web for humans as a side effect? Do you find yourself doing the same?
Add Tab Bar, Mega Menu & more to any website — no code Discussion | Link
submitted by /u/f311a [link] [留言]
I'm working with AWS for many years, and currently I'm working in product with suppose to be cloud agnostic. I started with AWS and now it's time to spin up it into Azure (because many enterprises using azure for some reason). I started in US EAST region in azure and at beginning I had an issue with Postgres Flexible, raised a support ticket, and in the result they recommended me to move to another region. The overall conversation to say this takes about 1 day. I've moved to US EAST 2, and after
“Why wouldn’t you want to be in both Pepsi and Coke?” says one venture capitalist. “It’s the same here.”
From battery life to privacy, there are many hurdles to the idea taking off.
A lot of recent discussion around Edge AI focuses on running increasingly larger local LLMs. Meanwhile modern smartphones already have enough compute for many practical computer vision tasks that don't require massive models at all. I recently built and released an Android feature that performs offline recognition of handwritten and printed Morse code from images and live camera frames. The final solution combines lightweight ML and computer vision techniques running entirely on-device. The AI module is under 5 MB, works fully offline, and runs on Android devices using LiteRT for inference. What made the project particularly interesting was that the entire ML pipeline was built from scratch: data collection, synthetic dataset generation, annotation, model training, evaluation, mobile optimization, and Android integration. Training was performed on a personal GPU workstation using TensorFlow/Keras, while annotation and dataset preparation relied on Label Studio and custom data-generation tools. While the problem itself is fairly niche, the project made me wonder whether we are overlooking a large class of small, highly specialized models that can solve practical tasks locally without requiring cloud infrastructure or large foundation models. What practical Edge AI applications do you think are currently underexplored? Demo video showing the feature running entirely on-device: • Downloading the optional AI module • Real-time camera recognition • Image recognition • Module removal https://youtube.com/shorts/Y2qOK0N1Bvk submitted by /u/VegetableLegal6737 [link] [留言]
Over the past few months I’ve been building VoiceIntego, an AI voice agent that answers calls and books appointments for service businesses (dental clinics, HVAC, plumbing). Here are some of the technical lessons that surprised me along the way. Latency is the whole game With text chatbots, a 2-second delay is fine. On a phone call, anything over ~800ms feels broken — people start talking over the AI. The hard part isn’t the LLM response; it’s the round trip: speech-to-text → LLM → text-to-speech, all streaming. You have to stream every stage and start TTS before the full response is generated. Interruptions break naive pipelines Real callers interrupt. “Actually, can we do Tuesday instead—” mid-sentence. A simple request/response loop can’t handle this. You need barge-in detection: monitor the incoming audio stream and cancel the current TTS playback the moment the caller starts speaking again. Booking logic needs guardrails, not vibes Letting the LLM “decide” availability is a recipe for double-bookings. The reliable pattern: the LLM extracts intent (date, time, service), then deterministic code checks the actual calendar API and confirms. The model handles language; your code handles truth. Confirmation loops matter more than you’d think Always read the booking back: “So that’s a cleaning on Tuesday the 9th at 2pm — correct?” Phone audio is noisy and names/times get misheard constantly. One extra confirmation turn cuts errors dramatically. Phone numbers and edge cases everywhere Voicemail detection, callers who mumble, background noise, people who say “yeah” to mean no. The happy path is maybe 20% of the work. If you’re building something in this space, happy to compare notes. You can see what I’m working on at VoiceIntego .
Most powerful AI/agent tools nobody talks about, and it leaves you behind IMO 1. Instructor define a Pydantic model, get clean structured JSON out of any LLM every time → https://github.com/567-labs/instructor 2. Octopoda gives any AI agent persistent memory and catches it when it loops and quietly burns your tokens. open source → https://www.octopodas.com 3. E2B secure cloud sandboxes so your agent can actually run the code it writes without nuking your machine → https://e2b.dev 4. Firecrawl turn any website into clean, LLM-ready markdown in one API call → https://firecrawl.dev 5. Composio plug your agent into 1000+ apps (Gmail, Slack, GitHub) with the auth handled for you → https://composio.dev 6. LiteLLM one API for 100+ models across OpenAI, Anthropic and local, swap without rewriting a line → https://github.com/BerriAI/litellm what are yours, let me know and I will add it to the list next month! submitted by /u/DetectiveMindless652 [link] [留言]
You can't imagine how bad my experience with Next.js has been recently. I have two projects running on the same Ubuntu laptop: One Next.js app One TanStack app The Next.js dev server was literally the biggest process on my entire machine, sitting at almost 4GB of RAM and absolutely murdering my old Lenovo. Even Brave and VScode consume less memory. Meanwhile, the TanStack app was using around 800MB. Still not amazing, but nowhere near as insane. Out of frustration, I asked an AI to help optimize the Next.js setup. It ended up changing some config to force Webpack instead of the default Turbopack setup and also added limits to how large the cache could grow. Believe it or not, memory usage dropped from nearly 4GB down to around 1–2GB. That's still a ridiculous amount of RAM for a dev server, but at least it no longer tries to consume every available resource on my laptop. Maybe Vercel is thinking that everybody has a fancy Macbook M4 with 64GB ram?! P.S. both codebases are small, max 50k lines in each. submitted by /u/hanzo2349 [link] [留言]
TL;DR Reconciliation is the part of a payments stack nobody architects for on day one and everyone pays for on day 200. The job: prove that every internal transaction matches the acquirer's settlement file, in the right currency, with the right fees, on the right value date — or surface the diff fast. The mechanics: normalize files → land into an events table → project to a read model → diff against the internal read model → buckets for ops to resolve. The boring details (file formats, fee parsing, FX rounding, value dates) are where 90% of the work lives. If you've ever opened a CSV from an acquirer at the end of the month, sorted by amount, and tried to "just match it in Excel" — yes, this post is for you. What "reconciled" actually means A transaction is reconciled when, for the same logical payment, three views agree: What you sent — your internal record of the charge/payout (your read model). What the acquirer says happened — their settlement file or API report. What the bank actually credited / debited — the bank statement. Disagreements are normal. Persistent disagreements are how you lose money slowly and never know. The shape of a settlement file Across the major acquirers, settlement files look broadly similar — and broadly different in the places that matter: Field Variants you'll see Transaction reference acquirer's transaction_id , sometimes plus a merchant_reference round-tripped from you Gross amount minor units / decimal; transaction currency vs settlement currency Fees inline per-row, or aggregated at the file footer, or in a separate fees file FX inline rate vs separate FX file; sometimes only the converted amount Value date when the bank actually moves money — often T+1/T+2 from event date Adjustments refunds, chargebacks, fee corrections, reserves — usually mixed in Encoding UTF-8 if you're lucky; CP1252 / fixed-width / SWIFT MT940 if you're not Granularity one row per transaction or daily aggregates per merchant or both There's no industry-clean
The largest index in the world won't relax its rules to let SpaceX enter early.
The test hung for 30 seconds. The response had already fired. One moved line fixed it. The test hung for 30 seconds, then timed out. The browser had received the response. The page had loaded. The data was there. The test was still waiting. The wizard I was writing a helper to walk through a 4-step booking wizard. After clicking "Next" on step 1, the page does a full navigation — window.location.href to step 2. Step 2 immediately loads doctor data from the API. The helper looked like this: await Promise . all ([ page . waitForURL ( /step=2/ ), step1Next . click ()]); await page . waitForResponse ( r => r . url (). includes ( ' /doctors ' )); Standard pattern: wait for navigation, then wait for the data request. Timeout. Every time. What I checked first The URL pattern. Maybe /doctors wasn't matching. Opened the network tab. The request was there: GET /api/v1/doctors , 200, 47ms. Correct URL, correct response. The page looked fine. The data was rendered. The test said it was waiting for a response that had already happened. Added waitForLoadState . Still hung. Added an explicit waitForSelector for an element that was clearly on the page. That passed. Then waitForResponse hung again. The response existed. The test couldn't see it. What was actually happening page.waitForResponse() is not a query. It doesn't look at what happened. It registers a listener — from that exact moment forward — and waits for the next matching response. The sequence in my code: Promise.all resolves when the URL changes to step=2 By the time the URL changed, step 2 had already loaded Step 2 had already sent and received /api/v1/doctors Then waitForResponse registered its listener Now it's waiting for the next /doctors response Which never comes Playwright doesn't buffer missed events. If the response fired before the listener was registered — it's gone. The fix await Promise . all ([ page . waitForURL ( /step=2/ ), page . waitForResponse ( r => r . url (). includes ( ' /doctors ' )), step1Next