Agostino De Marco

knowledge of b-reps and cad geometry in general is a lost discipline there are maybe a couple hundred people in the world who actually know it most of them already retired or still working on the legacy kernels nobody really learned it in the last 30 years because it was not cool and the most interesting stuff just lives as tribal knowledge among those who actually built kernels before

SMLIBPY 0.5.x is out → smlibpy.classcad.ch It contains hundreds of bugfixes and SMLIB kernel patches, it should run a lot more stable and with better error management. Also adds new features, there shouldn't be anything left in smlib/usd_brep that smlibpy cannot reproduce.

这是我自己开发的 后面会更新到 github.com/ayaka-notes/ayaka…

This is a virtual human body with 700 muscle actuators, 206 joints, and 90 body segments. It's fully open source, and researchers can use it to simulate human movement through muscle-level control.

Introducing SKY-001, the first Engineering World Model. On CAD and BIM tasks, it beats GPT-6 Astra and every frontier model we tested: -> 51-125x faster - > 150-210x cheaper -> Higher IOU than all frontier models SKY-001 lets you dream a physical object before you build it. 18 months of work. Built by the team out of Maluuba's deep learning lab (acq. by @MSRResearch). The first ‘AI General Engineer’ will be the backbone for Autonomous Manufacturing.

One of my hero's in CAD is George Allen. Here is his latest presentation comparing BREPs and Implicit geometry from the #CDFAM conference in Japan: youtube.com/watch?v=P0gAMHoK…

now you know

Every week someone tells me they vibe-coded their app over the weekend and don't need developers anymore. Before it touches a paying customer, make sure it includes: > a schema someone designed, instead of one the AI improvised table by table > login that still works when someone puts a plus sign in their email > password reset links that expire and work once > MFA, plus a recovery path for the user who lost their phone > sessions that time out, and a way to kill every session for one user > SSO for the enterprise customer who won't sign without it > SAML, because that customer's IT team doesn't do magic links > SCIM, so a fired employee loses access the moment IT offboards them > roles and permissions deeper than "admin" and "everyone else" > checks that stop user A from reading user B's data by changing one number in the URL > tenant isolation, so one customer's bug never shows another customer's records > an admin "log in as this user" button for support, with an audit trail on every use > rate limits on login, so nobody can guess passwords at scale > lockouts that stop attackers without locking out your CFO the night before the board meeting > database migrations that run forward and roll back > migrations that don't lock the main table at 2pm on a Tuesday > indexes, because the query that was instant on 50 test rows times out on 5 million real ones > connection pooling, so a traffic spike doesn't exhaust the database > backups every night > a restore from those backups, tested, because a backup you've never restored is a hope > point-in-time recovery for the day someone runs a delete without a where clause > soft deletes, so "I deleted it by accident" is a support ticket and not an incident > validation on the server, not just in the form > timezones stored right, so the 9am reminder doesn't fire at 4am > the customer with an apostrophe in their last name > emoji, accents and right-to-left text in every field > money stored as integers, because 0.1 + 0.2 doesn't equal 0.3 in floating point > currency, rounding and tax rules for every country you sell into > a data model that survives your second customer asking for "one small change" > idempotency keys, so a retried payment doesn't charge the card twice > deduplication for the user who clicks submit four times > pagination that still works on page 400 > exports, because sooner or later every customer wants their data in a spreadsheet > imports that survive the CSV someone saved in 2009 > retention rules, and code that deletes what your contract says you'll delete > secrets out of the code, out of the repo and out of the AI chat history > rotating every key the AI pasted into a config file last month > confirming every package the AI installed exists and is the one you meant > dependency scanning, because the AI pulled in libraries nobody reviewed > input sanitization everywhere a user can type > protection against SQL injection, XSS, CSRF and the rest of the OWASP list > file uploads that get scanned, size-limited and stored where they can't execute > CORS rules that aren't "allow everything" > security headers on every response > encryption at rest and in transit > least-privilege access for everyone, including the AI agent holding production credentials > logs that record who did what, without recording passwords, tokens or card numbers > a penetration test before your enterprise customer's security team runs their own > answers to the security questionnaire every enterprise buyer sends, with evidence behind each one > a disclosure process for the day a stranger emails you a vulnerability > a plan for the day a laptop with production access gets stolen > SOC 2, which means policies, evidence and an auditor, not a checkbox > HIPAA, the moment a single patient record touches your system > a BAA with every vendor that touches that data, including your AI model provider > audit trails that show who viewed a record, not just who changed it > PCI scope, and card numbers kept out of your database > GDPR deletion requests that reach every table, backup and log > data residency for the customer whose contract says EU only > quarterly access reviews someone signs off on > dev, staging and production environments that match each other > infrastructure written as code, so the setup lives somewhere other than one person's memory > a deploy pipeline that runs the tests before anything reaches customers > one-click rollbacks, because Friday deploys happen > zero-downtime deploys, because your customers don't have maintenance windows > feature flags, so you can ship the code without shipping the feature > autoscaling for the Monday morning spike > a CDN, so the app loads fast in Singapore too > DNS, SSL certificates, and renewals that don't expire on a Sunday > background job queues, so slow work doesn't freeze the page > retries with backoff, so one flaky API call doesn't become a lost order > a dead-letter queue for the jobs that fail every retry > cron jobs that don't run twice the day you add a second server > caching, and clearing that cache when the data changes > SPF, DKIM and DMARC, so your password resets don't land in spam > bounce and complaint handling on every transactional email > storage rules, so you stop paying to keep 2021's temp files > cost alerts, so a runaway agent loop shows up the same day and not on the invoice (we learned this one for $1,382.59) > a disaster recovery plan, written down and tested once a year > a second region, if your contract promises uptime one region can't deliver > structured logs you can search at 3am > error tracking that groups the same bug instead of sending you 4,000 emails > uptime checks from outside your own network > alerts that page a human, tuned until they stop paging for nothing > dashboards for latency, error rate and throughput > tracing for one slow request across every service it touches > an on-call rotation, and a person who picks up > runbooks, so the engineer on call knows what "queue depth critical" means > postmortems that change something > a status page customers check before they email you > unit tests written by someone who knows what the logic should do > integration tests for every third-party API you depend on > end-to-end tests for signup, checkout and the other flows that make you money > load testing before the launch email goes out > test data that looks like production without being production data > regression tests, so fixing bug 41 doesn't bring back bug 12 > testing on the five-year-old laptop your biggest customer's ops team still uses > accessibility compliance, because the enterprise contract requires it > subscriptions, upgrades, downgrades and proration > failed-payment retries and dunning emails > invoices with the customer's PO number on them, because procurement won't pay without it > sales tax and VAT > refunds, credits and partial refunds > usage metering that matches what you bill, to the cent > annual contracts with custom terms your billing logic never planned for > revenue reports your finance team can reconcile > webhooks that verify signatures > webhooks that retry, with a log of every failed delivery > a versioned API, so you can change it without breaking your customers' integrations > API keys customers can create and revoke > API rate limits that protect you without blocking real integrations > a plan for the day a third-party API changes its response format without telling you > OAuth token refresh, because tokens expire at the worst possible moment > a sandbox where customers can test their integration > protection against prompt injection in every field that reaches the model > customer and patient data kept out of prompts that leave your network > a model spend cap per customer, so one heavy user can't run up your bill > evals, so you find out when a model update makes your answers worse > a fallback for the afternoon your model provider goes down > a migration plan for the day your model gets deprecated > prompt and output logs for debugging, minus whatever you're not allowed to keep > a human approval step for anything the AI does that can't be undone > pages that load on hotel wifi > empty states, loading states and error states on every screen > error messages a customer can act on, instead of "something went wrong" > forms that keep what people typed when one field fails validation > emails that render in every mail client your customers use > notifications people can turn off > undo > keyboard navigation and screen reader support > translations, with dates and numbers formatted for each locale > a back button that does what people expect > code a human can read > code review on every change > a branching strategy, so two people can work without overwriting each other > monthly dependency upgrades, so you're never two major versions behind > framework upgrades before the old version stops getting security patches > deleting the dead code the AI left behind from its first three attempts > splitting up the 2,000-line file the AI kept appending to > architecture decisions written down, with the reasons > a README that gets a new engineer running locally in under an hour > documentation for whoever inherits this > an admin panel for your ops team > support tooling, so customer success can answer questions without pinging engineering > a changelog customers can read > terms and a privacy policy that match what the code does > every account, domain and repo in the company's name, not the name of whoever built the prototype > a bus factor higher than one Oh, and besides keeping all of this working every day, forever… your vibe-coded app will still need people who know what they're doing: > reading every line the AI wrote before it ships (a senior engineer) > designing the data model before your second customer breaks it (a backend engineer) > explaining why the AI's fix for one bug created two new ones (a senior engineer, again) > deploys, rollbacks, servers and the cloud bill (a DevOps engineer) > answering the page at 3am when payments stop (whoever's on call) > patching the framework the week a vulnerability goes public (security) > walking an auditor through how patient data moves (security and compliance) > testing what the AI says it tested (QA) > running a migration on a live database without losing a row (a backend engineer) > saying no to the feature that breaks three others (a tech lead) > turning "works on my laptop" into "works for every customer at once" (an architect) > debugging the code when the AI that wrote it can't (a senior engineer) > remembering why it's built this way, a year from now (someone who was there) …wishing them the best 🫡

So NVIDIA open sourced a b-rep kernel, and X blew up. I was a bit surprised by the hype - because it only means that pretty much nobody understands what SMlib is. So what is it, really, and (why) does it matter? 👇

We officially release smlibpy open source. A python API for the smlib nurbs kernel (inspired by cad-query, build123d & classcad). A wasm compile for javascript/ts (1.8mb dl/brotli total). And a MCP for agents. → smlibpy.classcad.ch → github.com/awv-informatik/sm… Thread ⤵

Over 5.6 billion tokens (and 48 hours!) later, Opus 5.5 has generated an entire A380 full of animations 🤯 The craziest thing is this is a REAL svg with over 600 parts.. and it's still doing reviews/fixes as I type this 😂

Opus 5.5 + /anatomy skill is insane for motion animation • Interactive isometric wireframes you can rotate, inspect and explore • WebGL shaders for fire, water, plasma and more • Real 3D motion, with individual parts that rotate send to Claude: skills.wheresryan.sh/anatomy

Software is over? Brandon Thomas, who describes himself as a software veteran with about 15 years in the industry and roughly a decade of work in Rust, is building the suite under the name Artcraft. He used Anthropic’s Claude Opus 4.5 to write the replacements in Rust. The set is meant to cover more than photo editing: Photocraft for Photoshop, Vectorcraft for Illustrator, Filmcraft for Premiere, Lightcraft for Lightroom, Effectcraft for After Effects, Designcraft for InDesign, and Printcraft for Acrobat Pro. The apps are free, with no subscription. Thomas says users can download the source, change it, and send fixes. He also says the project has a team behind it and will not be dropped after the announcement. On the timeline, he first said Artcraft would reach 100 percent parity with the Adobe apps within a month. In comments on Hacker News he pulled that back, while still saying 99 percent parity would take months rather than years. That gap between the claim and the current software is already visible. The apps are early, and people trying them have reported trouble with basic functions. They can resemble the Adobe programs they are named against, but the early reports do not describe them as ready replacements for tools that have been in professional use for years. Thomas ties the project to Adobe’s cancellation fees. In June 2024 the US government sued Adobe, alleging that the company hid early-termination charges and made subscriptions hard to cancel. Customers who ended certain annual plans early could be charged about half of the remaining payments. Adobe disputed that account and said its terms were clear and cancellation was straightforward. In March 2026 the company agreed to a $150 million settlement: $75 million in civil penalties and $75 million in free services for customers, plus clearer fee disclosures and an easier way to cancel. Adobe continued to deny wrongdoing. How seven free apps stay funded is a separate question. Thomas says Artcraft’s other business, selling tokens for AI image and video models, will help pay for development. He is also asking users to file bugs and contribute code. The legal exposure is left open. A suite that tracks Adobe’s products too closely is the sort of thing Adobe would be expected to notice, even if the public case against Adobe’s subscription practices has already been made in court and in the settlement. Existing free options already cover part of this ground, including GIMP, Krita, and Photopea for Photoshop-type work. Artcraft’s pitch is that an Adobe-like layout would make the switch easier, without the subscription or the cost of leaving early. Thomas expects other developers to do the same thing with other paid software. In his words, people can now make highly performant, cross-platform, clean-room equivalents that match the function of existing apps, and nothing is stopping them. He extends that to search, phones, and infrastructure, and to stripping ads out of software. The line he put on the project is the one in the headline: “Software is over.”

Gilbert Strang, an MIT professor, taught the same linear algebra course for 62 years. When he delivered his final lecture in May 2023, students from around the world tuned in online to watch. The course is MIT 18.06 Linear Algebra. Millions of machine learning engineers, data scientists, quants, and self-taught programmers learned the essential math behind AI from his clear, free video lectures, even though most never stepped foot on the MIT campus. Strang joined the MIT faculty in 1962 and retired in 2023. When MIT launched OpenCourseWare in 2001–2002, he was one of the first to embrace it fully. While many professors hesitated, Strang saw it as an opportunity to share mathematics with everyone. He filmed his lectures and made them freely available. He completely changed how linear algebra is taught. Instead of starting with abstract vector spaces and proofs, Strang began with something simple and visual: matrix multiplication. He built intuition first using concrete examples, then introduced more advanced ideas like eigenvectors and singular value decomposition. He insisted that students should be able to explain every concept with a small, tangible matrix before moving to theory. Beyond the content, his teaching style stood out. He spoke to students with genuine respect, patience, and kindness, never using words like “obviously” or “trivially.” He regularly paused to check if anyone was lost and treated beginners as thoughtfully as he would his colleagues. As a result, Strang became the default linear algebra teacher for much of the planet. Universities in many countries began recommending his lectures to their own students. Some even replaced their in-person courses with his videos because they could not match their clarity. His final lecture ended with a long standing ovation. Strang seemed surprised by the applause, smiled humbly, and simply thanked everyone. In his short comment under the YouTube video, he expressed gratitude for a wonderful life of teaching and hoped others would continue teaching the subject well. No self-promotion, no grand farewell—just quiet sincerity. When you add up every version, every upload, help sessions, and all the different recordings MIT has shared over the years, the total has surpassed 20 million views. Today, the full course, including all lectures, problem sets, and solutions, remains freely available on MIT OpenCourseWare. One of the most important mathematical foundations of modern AI is still just one click away.

We'll be spending a lot more time trying to understand the outputs of language models. A few thoughts, tips & tricks: Writing. Something I've had success with: Ask your LLM to explain something in ASD-STE100, it's a controlled language specification originally developed for aerospace maintenance documentation. LLMs well-versed in this language and it comes with heavy constraints on clean writing style that I often find a lot more readable. Sometimes I've tried to soften it a bit e.g. ask for "80% of the way to ASD-STE100" because the spec is quite stringent. But even better: Diagrams / images. Instead of writing, ask your LLM to create a diagram. These can be a lot easier to process, parse, and understand. But even better: Web pages. Ask for output "in HTML" to get a beautiful, interactive webpage. LLMs are getting really good at frontend and can create beautiful experiences, animations, etc. But even better: Explainer videos. The output format I am most bullish on is fully custom / bespoke explainer videos generated on any arbitrary topic. Experiment with things like "Create a 3b1b style video explainer on X. Use my ElevenLabs API key for audio narration". (you'd need an API key for the latter or you can ask your LLM to find you decent free alternatives that use your local compute). This is actually starting to work! In summary: - As LLMs get better, they will do more and more of the legwork autonomously, and a lot more of our work will rise up the abstractions into oversight and understanding. - Luckily, LLMs can help here too because as intelligence and code are increasingly abundant, you can ask for large, custom, discardable software artifacts (e.g. web apps, video explainers) that would have never made sense to create before. Push the boundaries here and you'll be surprised.