标签：#c

Gone are the hours of careful thought and planning that go into coding a new feature. Vibe coding is too risky though, so another Driven Development was created. I'm referring to SDD (Spec Driven Development) of course. The vibe coding approach is great for prototypes and throwaway code, but this way of working falls apart when teams realise that the code needs to be maintained. So the thing that helps fix this is SDD. Create a spec once from clear technical specs and then generate some high quality code. Sounds great, right. Reminds me of IaC, where you use a templating language to create infrastructure. Software as Code maybe. SaC anyone? Unfortunately, in practice it's not that straightforward. Thoughtworks have placed SDD into an "Assess" category and warned that it could be an anti-pattern for releasing software. Deterministic vs Probabilistic This article isn't about SDD. I'm more interested in discussing the output of SDD and how that is tested. Code can now be generated fast these days. So what better to test AI-written code than with AI itself. There are a lot of concepts and technical terms for the Quality Assurance part of AI generated code. One of these is the LLM-as-a-Judge idea. This idea is used to score the output of an LLM based on some explicit criteria. Traditionally, the way to evaluate an LLM was to judge its output on the helpfulness or faithfulness (using something called "exact-match" metrics). Sometimes it was usually down to a human to do this. It also changes the way that Quality is Assured when dealing with AI-written code. Traditional QA is built on deterministic checks; either something does or does not fail. Something like expect(x).toContainText(y); . A failing test means that something is wrong. Then the bug can be fixed in the code and the test will pass. However, the outputs of an LLM are probabilistic , so it breaks the traditional pass/fail model. This is where a judge comes in. Instead of pass/fail, it can assign a score based o

Building a semantic search engine for an e-commerce catalogue doesn't require a team of PhDs or a six-figure cloud budget. In this tutorial, I'll walk you through a production-ready pipeline using open-source tools: sentence-transformers for embedding, FAISS for vector indexing, and FastAPI for serving. The core insight is that semantic search isn't magic — it's just good engineering wrapped around a pre-trained language model. We'll start by setting up a product embedding pipeline that transforms your catalogue (title, description, category, attributes) into dense vectors. The key architectural decision is whether to embed each product as a single vector or to use late interaction models like ColBERT that preserve token-level detail. For most e-commerce use cases with fewer than 1 million SKUs, single-vector embedding with sentence-transformers' all-MiniLM-L6-v2 offers the best balance of speed and accuracy. The entire indexing pipeline — from CSV export to queryable vector index — runs in under 100 lines of Python. The re-ranking layer is where most tutorials stop and real-world systems begin. Pure vector similarity doesn't understand your business: it doesn't know that out-of-stock items should be deprioritised, that high-margin products should float up, or that a customer's purchase history should influence results. I'll show you how to build a hybrid scoring function that blends semantic relevance (cosine similarity), business rules (margin, inventory), and personalisation signals (user embedding) into a single ranked result set that returns in under 100ms. Canonical: https://alteglobal.ai/insights/ecommerce-ai-automation-personalisation-fulfillment/

A few weeks ago I spent twenty minutes hunting for a ChatGPT conversation I knew existed. It was a debugging session. The model and I had traced a race condition in a KV cache layer — and the final write-up was genuinely good: why the bug only fired under concurrent writes, the fix, and a checklist for avoiding that whole class of bug. Three weeks and a hundred chats later, ChatGPT's search couldn't surface it. I re-derived everything from scratch. That's when it hit me: AI chat is where a growing share of my real engineering work happens — and it's the worst archive I own. We're producing work in a place designed to lose it Think about what's sitting in your ChatGPT (or Claude) history right now: code you debugged line by line over ten turns architecture trade-offs you talked through before writing the design doc that regex / SQL / jq incantation you will absolutely need again migration plans, incident notes, dependency-upgrade research In any other tool, we'd call these documents . We'd file them, tag them, grep them. In ChatGPT, they're just... chat number 247. The obvious fixes don't really work I tried everything before building my own solution, so you don't have to: The official export. ChatGPT will happily email you a ZIP of your entire history — all of it, at once, as raw HTML and JSON. It's a backup, not a filing system. You can't export the one conversation that matters, and let's be honest: nobody ever greps the ZIP. Copy-paste. The copy button under each reply grabs Markdown, and Notion converts most of it. But it's one message at a time, your own prompts aren't included, and long tables and code blocks arrive mangled. For a 30-message thread, that's your afternoon. Share links. A share link is a bookmark, not a copy. The content never enters your workspace, your search can't index it, and the link dies the moment you delete the chat. Every one of these fails the same test: can I find this answer in 30 seconds, three months from now? What actually worked

Your teachable AI intern for everyday browser work Discussion | Link

I made ClickHouse and Postgres Fight to Find Out 🥊 One Mac Mini. Two databases. 100 million rows of...

GitHub announced agentic autofix for code scanning alerts in public preview on July 10, 2026. Primary source: GitHub Changelog, July 10, 2026 . The wrong metric is “percentage of alerts with a generated patch.” Generation is only the first transition: alert -> candidate -> build -> tests -> security oracle -> human review -> merge -> post-merge observation This is an evaluation proposal, not a benchmark or assessment of GitHub's preview. Choose a bounded canary Start with repositories that have active owners, deterministic builds, relevant isolated tests, reversible releases, and no automatic production deployment from candidate patches. Exclude abandoned code, safety-critical paths, and repositories with unreliable tests. Assign the canary deterministically—for example, hash a stable alert ID into a fixed percentage. Do not move difficult results out of the cohort after seeing them. Record every attempt, including abstentions and failures: attempt_id : " <id>" alert_class : " <normalized class>" base_revision : " <commit>" outcome : generated : true applied_cleanly : true build_passed : true tests_passed : false security_oracle_passed : false human_decision : " rejected" failure_class : " semantic_incomplete" escaped_to_default_branch : false The schema is local evaluation metadata; it does not imply that GitHub exposes these fields. Classify the earliest broken invariant Class Meaning No candidate Tool abstained Scope violation Unrelated or forbidden paths changed Apply failure Patch does not apply to recorded base Build failure Patched revision cannot build Regression Existing behavior broke Semantic incomplete Alert changed but security property remains broken Overcorrection Valid behavior was blocked Test manipulation Validation was weakened or removed Stale base Result targeted another revision Review ambiguity Human cannot establish why the patch is safe Infrastructure Evaluation could not complete Post-merge escape Later evidence disproved acceptance Use one

GitHub announced on July 14, 2026 that security reviews are available in the GitHub Copilot app. Primary source: GitHub Changelog, July 14, 2026 . The meaningful research question is not whether people click Accept. It is whether they can build an evidence-backed decision when guidance is useful, incomplete, or wrong. understand change -> inspect evidence -> challenge findings -> verify uncertainty -> accept, reject, or escalate This is a proposed research protocol, not a completed study. It does not invent product fields or report findings. Build scenario cards scenario_id : " SR-03" repository_type : " synthetic" seeded_conditions : - " one relevant issue" - " one plausible but irrelevant concern" - " one important omission" participant_goal : " ready, blocked, or escalate" success_evidence : - " decision cites inspected code" - " unsupported claim is challenged" - " unresolved uncertainty is recorded" stop_conditions : - " real credentials appear" - " a live repository could be modified" - " participant mistakes study output for production approval" Vary the seeded mix so participants cannot learn that every scenario contains exactly one true and one false finding. Establish ground truth independently before sessions. Recruit people who hold different review responsibilities: routine reviewers, maintainers, security specialists, less-experienced reviewers, and people using keyboard navigation or assistive technology. Do not collapse every group into one average. Require a decision record Decision: ready | blocked | escalate Evidence inspected: - file and relevant lines - test or documentation Guidance accepted: - claim and evidence Guidance rejected: - claim and reason Unresolved: - question and next owner Spoken confidence is not the outcome. This artifact exposes whether acceptance connects to evidence. Measure relevant issues identified, unsupported claims challenged, evidence references, correct escalation, time, and confidence before and after inspection. No

GitHub announced on July 8, 2026 that GitHub Mobile can start a Copilot cloud-agent workflow to fix pull-request merge conflicts. Primary source: GitHub Changelog, July 8, 2026 . The unsafe mental model is “tap once and the conflict is solved.” A safer model is: mobile intent -> bounded remote task -> proposed patch -> verification -> human merge This is a source-based checklist, not a hands-on product assessment. Exact controls and permissions must come from current GitHub documentation. Record the handoff repository : " owner/project" pull_request : 123 base_branch : " main" expected_base_sha : " <commit>" expected_head_sha : " <commit>" allowed_scope : - " src/example/**" - " tests/example/**" forbidden_scope : - " .github/workflows/**" - " deployment/**" required_checks : - " unit-tests" reviewer : " <responsible human>" expires_at : " <UTC timestamp>" This operator artifact is not a representation of the mobile UI. It preserves intent across interruptions, network changes, and the delay between delegation and review. Before handoff, confirm repository, pull request, branches, expected files, sensitive paths, required checks, and the person responsible for merge. Never place secrets, customer data, or private incident details in the instruction. A bounded instruction is better than “make CI green”: Resolve conflicts between the recorded base and head revisions. Preserve documented behavior, limit changes to the listed paths, do not modify workflow or deployment configuration, and return a patch without merging. Verify the returned revision the result belongs to the expected repository and pull request; base and head revisions still match the handoff; every changed file is expected or explained; no conflict markers remain; no workflow, ownership, deployment, or policy file changed unexpectedly; tests ran against the exact reviewed commit; tests were not weakened or removed; a human can explain the semantic choice made for each conflict; the reviewed commit is the

GitHub announced on July 14, 2026 that Copilot for JetBrains expanded bring-your-own-key capabilities. Primary source: GitHub Changelog, July 14, 2026 . Provider and model selection looks like two dropdowns, but behaves like one dependent workflow: credential context -> provider -> compatible models -> confirmed session This is a proposed accessibility test plan, not a hands-on review. It does not claim that the current product has an accessibility defect. Test outcomes, not widget assumptions A keyboard or screen-reader user should be able to reach the provider control, discover its name and current value, inspect options, commit or cancel, understand that model choices changed, and select a compatible model without losing context. Use this matrix: Case Action Keyboard expectation Screen-reader expectation State expectation P1 Reach provider Visible focus Name, role, value No change P2 Open options Documented key works Expanded state is clear Existing value retained P3 Browse providers No focus escape Option and selection announced Browsing does not commit P4 Select provider Pointer not required New value announced once Model refresh begins M1 Reach model after refresh Focus not stolen Availability communicated Options match provider M2 Search models Keys do not conflict Query and result are clear Search does not select R1 Change provider later No trap Invalidated model explained Stale pair cannot submit E1 Loading fails Retry/cancel reachable Error and next action announced Last valid state is clear The matrix separates interaction, announcement, and state correctness. A control can pass one and fail another. Record the environment ide : " <product and exact version>" plugin : " GitHub Copilot <exact version>" os : " <name and version>" assistive_technology : " <name and version>" keymap : " <default or named alternative>" initial_state : " <unconfigured or existing selection>" Vary one versus many providers, short versus long model names, loaded/loading/empty/err