今日已更新 279 条资讯 | 累计 31547 条内容
关于我们

标签：#t

找到 15039 篇相关文章

AI 资讯

The LLM Should Never Do the Math

A CFO will not act on a number an LLM eyeballed. They will not act on a number the model "estimated" by reasoning over a usage dump. And they should not — because the moment a language model emits a dollar figure it computed itself, that figure is a guess wearing the costume of a fact. This is the design constraint behind databricks-cost-leak-hunter , the pilot skill of the databricks-pack v2 rebuild shipped in the claude-code-plugins marketplace ( PR #906 ). Given a live, authenticated Databricks workspace, it surfaces real cost leaks across four named categories, ranks them by monthly dollar impact, and emits a report a finance reader can act on. The marketplace validator graded it B (88/100, zero errors). The SKILL.md is 329 lines. The single most important thing in it is a rule the model is structurally prevented from breaking: the LLM never does the dollar arithmetic. Why not just let the agent read the bill and summarize it? Because that is exactly how you ship a confidently wrong cost report. Hand a model a few thousand rows of system.billing.usage and ask it for the top cost leaks, and it will give you a fluent answer. It will add DBUs. It will multiply by a price it half-remembers. It will round. Every one of those steps is a place the model can be plausibly, invisibly wrong — and the output reads identically whether the math is right or hallucinated. The failure mode of an LLM doing FinOps is not a crash. It is a clean, well-formatted, wrong number. The fix is architectural, not prompt-engineering. The model is allowed to decide what to look for and how to explain it . It is never allowed to be the calculator. The dollar primitive: confirmed, never estimated Every confirmed figure comes from the customer's own billing tables — system.billing.usage joined to system.billing.list_prices . Not a model estimate. Not a public price list. The number Databricks actually billed. That join is defined once, as a priced CTE, and reused by every category query. Usage i

2026-06-29 原文 →
AI 资讯

What Actually Happens in the First Call With a US Team After Your CV Passes

You finally get the response. The CV cleared whatever filter it was up against, and now there is a calendar invite for a thirty or forty five minute call. Most developers treat this as the technical screen and prepare accordingly. They load up on system design questions, leetcode style problems, or deep dives into the stack listed in the job post. What actually happens in that first call is often lighter on code and heavier on whether the person on the other side can picture working with you week after week. The engineering lead or hiring manager is trying to answer a few practical questions the CV could not fully settle. Can this person explain their decisions without needing constant context? Do they push back on unclear requirements in a way that moves the conversation forward instead of creating friction? Do they already understand how remote contractor work tends to flow, or will every interaction need extra translation? The candidates who lose ground here rarely fail on raw technical ability. They lose it on rhythm and assumptions. Some over-prepare the technical side and under-prepare the part where they need to show how they handle ambiguity. Others treat every question as an interview question that demands a polished answer, when what the lead wanted was a working conversation. The call ends with a quiet sense that this person will need more hand-holding than the role allows. Timezone and async signals are another place people slip. When a candidate spends the call reassuring the other person that they can work US hours or that they are always available for meetings, it often lands as uncertainty. The reassurance backfires. Teams that hire contractors remotely have already accepted some timezone spread. What they want to hear is how you have made async work in the past, what you leave behind when you log off, and how you keep momentum without daily syncs. The calls that move forward feel like two people working a problem together. The candidate is not sitti

2026-06-29 原文 →
AI 资讯

Popular Tags: How I Used Browser Storage to Efficiently Manage User Data

As a solo developer working out of an RV, I've learned to appreciate the importance of staying organized, especially when it comes to managing user data in my Chrome extension, Tab Reminder. One of the key challenges I faced was efficiently storing and retrieving user-scheduled tabs, which led me to explore the world of popular tags in browser storage. During the development of Tab Reminder, I realized that using a simple key-value pair system wasn't enough to manage the complexity of user data. I needed a way to categorize and prioritize scheduled tabs, which is where popular tags came into play. By utilizing the localStorage API, I was able to store user-defined tags and associate them with specific tabs, making it easier for users to manage their scheduled tabs. One technical insight I gained from this experience was the importance of using a robust data structure to store user data. In my case, I used a combination of arrays and objects to store tag information, which allowed me to efficiently query and update user data. For example, when a user schedules a new tab, I use the following code to store the tag information: // Store tag information in localStorage const tags = JSON . parse ( localStorage . getItem ( ' tags ' )) || {}; tags [ tabId ] = tagName ; localStorage . setItem ( ' tags ' , JSON . stringify ( tags )); One lesson I learned from this experience is that even small, useful tools like Tab Reminder require careful consideration of data management. By leveraging popular tags and a robust data structure, I was able to create a seamless user experience that allows users to efficiently manage their scheduled tabs. If you're interested in trying out Tab Reminder, you can check it out at https://go.sg1-labs.us/tab-reminder .

2026-06-29 原文 →
AI 资讯

The 3-line discipline

When I write code in unfamiliar territory, I write three lines, then I run it. Then I write three more lines, and I run it again. I've been doing this for twenty-four years. It's the most specific habit I have. I almost didn't write this article, because the habit feels too small to be worth describing — but then I noticed that it's the part of my way of working that I can never seem to explain to someone in real time. It needs writing down. Three principles The discipline rests on three things I believe about writing code. They're not deep. They've just stayed with me. 1. Trust nothing but your own code. If you can't trust the code you wrote yourself, what can you trust? Not a library, not a vendor's documentation, not your own assumption from yesterday. The only thing in the system whose behavior you can fully verify is the code you just typed, by running it. 2. Write in code, not in language. If you're describing what the code should do in Japanese or English, you're spending the same time you could have spent writing the code itself. By the time the code runs, the description is already done — by the code, in a more precise form than any language could give it. 3. Make three lines complete. The three lines you just wrote should be complete. Error handling included. Validation included. Logging included. Not "I'll add validation later." Not "I'll wrap it in a try-catch later." Three lines, complete, then run. (There's a small exception to this. Sometimes you do want to ignore every error and move on — for instance, when you're trying to understand whether the happy path works at all before you care about anything else. That's a different mode, used deliberately. It's not the same as "I'll handle errors later.") Why three lines Three lines is roughly the unit of thought I can hold completely. Five lines, and I start guessing what the third line did. Ten lines, and I'm reading the code as if it were someone else's. Three lines is the size that stays mine. When thre

2026-06-29 原文 →
← 上一页 下一页 →