标签：#software

Let me tell you exactly what happened the first time I tried to set up Lambda manually. Four hours. IAM trust policies I didn't fully understand, ARNs copy-pasted into the wrong fields, an API Gateway that was technically configured but somehow not routing anything correctly, and a deploy that failed with an error message pointing me nowhere useful. I hadn't written a single line of actual business logic yet. That's when someone on my team mentioned the Serverless Framework. My first reaction was honestly skepticism — another abstraction layer sounded like another thing to learn and eventually fight with. I was wrong about that. This isn't a "look how clean this tool is" post. It's more like: here's what I actually did to get a Postgres-backed CRUD API running on Lambda, step by step, including the parts that tripped me up. What the Framework Is Actually Doing Under the Hood Worth knowing before you start: the Serverless Framework isn't magic. It's generating CloudFormation templates and submitting them to AWS on your behalf. Your Lambda functions, API Gateway routes, CloudWatch log groups — all of it gets provisioned from a single config file. It works with other providers too, but the AWS integration is where it really earns its keep. The console clicking and manual ARN-wiring that burns time at the start of every serverless project? Gone. Same deploy workflow whether you're building a REST API, an event processor, or a cron job. Once you've done it once, the second project takes a fraction of the time. What You're Building Four live endpoints backed by PostgreSQL. A Users table. Create, read, update, delete — nothing exotic, but a real enough foundation that you can extend it into something actual once this guide is done. You'll need an AWS account, the AWS CLI installed, and the Serverless Framework installed before starting. That's it. Step 1: Sort Out Your AWS Credentials Run this to create both config files in one go: bash cat << EOF > ~/.aws/credentials [def

Last week, Toronto hosted Tech Week. A city-wide celebration filled with events and workshops...

Why Senior .NET Engineers Rarely Trust User Input Most beginner C## developers discover TryParse() while learning console applications. It usually appears during a simple exercise: Console . Write ( "Enter quantity: " ); string ? input = Console . ReadLine (); if ( int . TryParse ( input , out int quantity )) { Console . WriteLine ( $"Quantity: { quantity } " ); } At first glance, it looks like a convenience method. A safer version of Parse() . A small utility. Nothing particularly interesting. But experienced .NET engineers see something completely different. They see one of the earliest examples of defensive programming. Because software engineering is not about handling perfect input. It is about surviving imperfect input. And in production systems, imperfect input is the rule—not the exception. TL;DR TryParse() is not just a conversion method. It introduces some of the most important concepts in professional software development: Defensive programming Input validation Runtime safety Exception avoidance Financial precision Domain modeling Reliability engineering Understanding why TryParse() exists is often more valuable than learning how to use it. Every Value in C## Starts With a Type One of the first concepts developers learn is that every variable has a type. int quantity = 10 ; decimal price = 25.99M ; string productName = "Laptop" ; bool isAvailable = true ; Simple. Yet this idea is foundational. Because types are not just containers. They are contracts. Each type defines: Valid values Memory layout Available operations Precision guarantees Runtime behavior When you choose a type, you are making an architectural decision. Why decimal Exists Many developers ask: Why not use double for money? Because financial systems require precision. Consider: double a = 0.1 ; double b = 0.2 ; Console . WriteLine ( a + b ); Expected: 0.3 Reality: 0.30000000000000004 The issue comes from binary floating-point representation. For scientific calculations, this is acceptable. F

The hidden cost of AI isn't generating code. It's understanding your codebase. For a long time, I assumed AI coding tools became expensive because they generated a lot of code. These tools can produce components, tests, SQL queries, documentation, and sometimes entire features on demand. If costs were climbing, the output volume must be the reason. The more I used these tools, the more I realized I was measuring the wrong thing. The expensive part isn't writing code. The expensive part is understanding what code should be written — and that work is mostly invisible. That realization changed how I think about AI-assisted development entirely. Two Prompts, Two Very Different Problems Consider these two requests: "Create a utility function that formats dates" and "Review this feature and suggest improvements." At first glance, both look ordinary. Both might even produce short answers. But they require completely different levels of understanding. The first is narrow and well-defined. The AI needs very little information before it can produce a useful answer. The second is open-ended. Before suggesting a single improvement, the AI may need to read multiple files, understand dependencies, follow existing patterns, compare implementations, and build a mental model of why the feature exists at all. The output might still be small. The work required to reach it is not. Why Agent Workflows Feel Different From Autocomplete This became much clearer when I started using AI agents. Traditional autocomplete is predictive — you type, the AI guesses what comes next. It's fast, cheap, and deliberately context-light. Agents behave differently. When you ask one to improve a feature or review a workflow, it doesn't immediately start generating code. It starts reading. It follows imports, finds related files, and tries to understand the system before touching it. That is exactly what makes agent workflows feel slower and more resource-intensive than autocomplete: they are spending effor

CAP Theorem Explained: Choosing Between Consistency, Availability, and Partition Tolerance in Databases Imagine you're trying to book a flight online, and just as you're about to pay, the website crashes. When you try to book again, you find that the flight is now sold out, even though the website initially showed available seats. This frustrating experience is a classic example of a database trade-off between consistency, availability, and partition tolerance. The CAP theorem, first introduced by Eric Brewer in 2000, states that it's impossible for a distributed data store to simultaneously guarantee more than two out of these three principles. In this post, we'll delve into the world of CAP theorem, exploring its fundamentals, real-world database examples, and design implications. Introduction to CAP Theorem Understanding the Basics of CAP Theorem The CAP theorem is based on three primary principles: Consistency : Every read operation will see the most recent write or an error. Availability : Every request receives a response, without guarantee that it contains the most recent version of the information. Partition Tolerance : The system continues to function and make progress even when network partitions (i.e., splits or failures) occur. Importance of CAP Theorem in Distributed Systems In distributed systems, where data is spread across multiple nodes, the CAP theorem plays a crucial role in understanding the trade-offs between these principles. By grasping the CAP theorem, developers can design more resilient and scalable databases that meet the specific needs of their applications. Brief Overview of the Blog Post This post will explore the CAP theorem in depth, using real-world database examples to illustrate the trade-offs between consistency, availability, and partition tolerance. We'll discuss the fundamentals of CAP theorem, examine CA, CP, and AP systems, and provide guidance on designing for each combination. By the end of this post, you'll have a solid un

Most API teams treat the contract as an afterthought: write code, generate a spec, then watch the two drift apart. Git-native API design reverses that flow. You treat the API contract as source code, version it in Git, and review every change the same way you review application logic. Try Apidog today This guide focuses on implementation discipline, not a single tool. You’ll design contracts in branches, review them in pull requests, and turn a committed spec into mocks, tests, and docs. The goal is simple: your Git history should also be your API history. If you already know what Spec-First tooling looks like and want the product walkthrough, read the companion piece on the git-native API workflow . This article stays focused on practice. What “git-native” means for API work Git-native means your API definition lives in your repository as a plain text file. Not in a proprietary cloud database. Not behind a vendor login. A .yaml or .json file sits next to your code and is tracked by the same version control system your team already uses. In many cloud-locked API design tools, the contract lives in the vendor’s backend. You edit through a web UI, and your repository only contains an export. That export can become stale, and your Git history no longer explains how the API evolved. The git-native model inverts that relationship: The file in main is the contract. Any GUI is a view onto that file. Branches, commits, pull requests, blame, and rollback all apply to your API surface. Mocks, docs, tests, and generated clients derive from the committed spec. A git-native setup has three core properties: The spec is a text file in the repo. Changes flow through normal Git operations: branch, commit, PR, merge. Downstream artifacts derive from the committed file, not from a separate database. Why design and develop APIs in Git You already trust Git with your code. Your API contract deserves the same treatment. 1. History When someone asks, “When did we add the cursor pagination

Microsoft’s OpenClaw-style agent appears in Teams, just like a human colleague, and automates your dull office tasks.

You don’t need expensive software for basic PDF tasks. In fact, all you need is a handful of free web-based apps.

A security reviewer finds a critical issue a day or two before the release of an application. While it's an important issue, it sets the team back weeks, frustrating their product management partners and customers. The review came at the most expensive time in the process. There are many examples of how work items move through different processes to deliver software in large companies. While GenAI has allowed us to rapidly create code, it also moved and exposed the bottlenecks in our processes. It has also caused us to re-examine where it is most effective to make certain decisions. This is the challenge, and a deliberate blend of automated, programmatic, and human judgment is well suited to help you solve it. We can borrow from the well-trodden path of value stream mapping here. It is useful for spotting bottlenecks and waste in a given process, but it's also valuable to ask the deeper question of who or what should own each step. Each option earns its place differently. Is there an earlier step that may reduce costs with an agent where it was previously limited by human availability? Or is the stronger determinism of a programmatic step more important for a critical piece of the flow? Some decisions should stay with human judgment, where confidence without context is a liability. The opportunity for security teams and other stakeholders is to scale their impact across these options rather than scaling headcount. Workflow-as-code is not a new idea. There are a number of existing engines where the workflow definition is its own entity, separate from the work itself. GitHub Actions defines pipelines in version-controlled files, while the execution happens on separate runners. Airflow and Temporal follow a similar pattern for data and application workflows. Because the definition lives on its own, a team can change how a given step runs without rebuilding the whole flow. That separation is what makes it practical to adjust who or what owns each step over time. Rather

You know the moment. You push the branch, open the PR, and immediately see it — the undefined return on the refund path, the token logged to the console, the TODO that was supposed to be temporary six weeks ago. The reviewer catches it four hours later and you reply "good catch, fixing now" as if someone else wrote that line. The first reviewer on most pull requests should have been the author. Half the comments you will receive — the missing null check, the untested error branch, the duplicate logic that could be extracted, the import that now goes nowhere — are things you would have caught with one more careful read-through. You skip that read because you have been in the code for two days and your brain completes the sentences for you. You see what you meant to write, not what is on the page. This post is about closing that gap with a structured AI-assisted self-review before the PR opens. Not to skip the human reviewer — to walk into the review with the obvious problems already gone, the test gaps already filled, and the PR description already written. So the reviewer's attention can land on what actually needs a second pair of eyes. The tool is branchdiff : a local browser app that runs your diff on localhost , stores everything in ~/.branchdiff/ , and keeps the AI surface controlled through an explicit branchdiff agent command API. Nothing leaves your machine until you decide to push it. Why "before the PR" is the right moment If you review after opening the PR, every AI fix becomes noise: a force-push, a re-read for your reviewer, another commit in the audit trail. If a teammate is already mid-review when you discover the bug, you look careless. The patch that should have been in the original push becomes a distraction for everyone downstream. If you review before opening the PR, the AI's output is a private workspace. You act on what matters, commit the fixes into your own history (often as fixup! commits you squash before pushing), and the PR that goes up i

The loop I didn't notice closing Seven weeks ago I started using AI for work. Two weeks after that, I published an article. Seven weeks after that — today — the article is one of sixteen, and they are all in a memory file that the AI reads at the start of every new conversation. I didn't notice the loop until I named it. This is a note about that loop, what it is, what it isn't, and why I keep publishing even though the loop doesn't strictly need me to. The shape It runs like this: I decide what to do. I work it out with the AI — usually in dialogue, sometimes by pasting raw code or data. The dialogue becomes a record. Sometimes a memory entry. Sometimes a published article. The record becomes context for the next conversation, which informs the next decision. It didn't look this clean while it was happening. The numbering is hindsight. From inside, the steps overlap. The first step is the one I keep. Direction is mine: what to build, what to write, what to negotiate. The history that shapes those decisions — twenty-four years of solo work, my company, my family, my health — is also mine. The AI is not setting direction. The second step is where most of the leverage is. I describe what I want to do as completely as I can, sometimes by handing over source code. Then I ask: does this look right? Is there a path I'm missing? Where would this break? I'm opening drawers — possibilities I half-saw in my own head — and checking which ones open cleanly. When one opens cleanly, that is the GO signal. Not "will this succeed" but "this is doable, so do it." The third step happens almost without effort. The conversation already exists as text. Some of it becomes a memory entry I add deliberately. Some of it becomes raw material for an article. The article writes itself partly because I have already explained the thing to the AI. The fourth step is the one that took longest to arrive — and the one I want to be most careful about describing. Three phases, not one The loop didn't

Over the past few months, I’ve increasingly noticed something through my network: more people from non-technical backgrounds are building software as AI tooling improves. Designers are prototyping product ideas. Product managers are testing workflows. Founders are building MVPs. Operators are creating internal tools. People who would not have called themselves “technical” a year ago are now using AI to make ideas tangible. I think this is genuinely exciting. It has never been easier to create. I even attended a hackathon where participants only had 20 minutes to build a demoable product! This raises the question: When AI makes building easier, how do we make sure understanding does not disappear? I recently published Thinking in the Age of AI , a guide for software engineers (you can check out my previous post here ). That guide focused on individual reflection for engineers: how to keep developing technical intuition, reasoning, and judgment while using AI tools. But the landscape has changed quickly. AI-assisted building is no longer only an engineering workflow. It is becoming a builder workflow accessible to all. And by builders, I mean anyone using AI to turn ideas into software-like artifacts: vibe coders designers product managers founders operators marketers students non-engineering team members So I wanted to create a new version of the system for this wider builder audience. Thinking in the Age of AI: Builder Edition The opportunity is real I do not think we should dismiss this shift. I have spoken with people from all kinds of backgrounds who are actively building now. People who previously had to wait for engineering time can now create something concrete. That changes the conversation. Instead of describing an abstract idea, you can show a flow. Instead of writing a long product spec, you can prototype the interaction. Instead of asking “would this work?”, you can test a rough version. That is powerful. But there is a trap. A prototype can look much mor

How a Product Sync Automation Project Transformed Customer Onboarding When people think about impactful engineering work, they often imagine distributed systems, high-scale infrastructure, or complex algorithms. One of the most impactful projects I worked on wasn't any of those. It was solving a seemingly simple problem: Keeping product data in sync across multiple retail systems. Years later, our CEO still remembers how much smoother customer onboarding became after this project. The Context: What is Commerce Connect? At Casa Retail AI, we have an internal platform called Commerce Connect (CC) . Commerce Connect acts as the central Product Information Management (PIM) system and serves as the source of truth for product information. Under the hood, it is built on top of a customized version of the open-source e-commerce platform Spree Commerce , extended with multi-vendor and multi-tenant capabilities. Its primary responsibility is simple: Collect product information from multiple retail ecosystems and distribute it to every Casa product that needs it. Once product data enters Commerce Connect, it is synchronized to multiple downstream systems. Why Product Data Matters Many applications inside Casa depend on product information. Product Consumers Once product data enters Commerce Connect, it is distributed to multiple systems across the Casa ecosystem. Customer-Facing Applications Several products rely on product information to provide context and improve customer experience: Lead management applications use product information during customer interactions. Ticket management systems link customer issues to specific products. Digital receipts display product names, images, and related details. Analytics & Reporting Product data powers business dashboards and reports, helping retailers answer questions such as: Which categories perform best? Which products attract the most attention? Which products generate the most complaints? It is also used for filtering and segme

I once submitted an essay with three citations that I hadn't personally verified. The AI had suggested them, and they sounded right. None of them existed. That's not a quirk or a bug — it's exactly how LLMs work. And once you understand why, a technique called RAG starts to make a lot of sense. AI assistants are remarkably good at sounding right. The model isn't lying — it's doing its best with what it knows. The problem is that what it knows has limits, and it doesn't always know where those limits are. Ask one about a recent event, a niche regulation, or anything from a source it's never seen — and it fills the gap anyway. Confidently. That's the gap RAG was built to close. Once you understand how it works, you'll have a much clearer picture of why some AI tools are genuinely reliable and others are just very convincing guessers. Here's what's actually going on. First, What's the Problem? Large language models (LLMs)—the technology powering AI assistants like ChatGPT and Claude—are trained on vast amounts of data from across the internet. That training gives them a remarkable ability to reason, summarize, and generate content. But it also comes with some real limitations: They have a knowledge cutoff. An LLM trained last year doesn't know what happened last month. They can hallucinate. When they don't know something, they don't say "I don't know"—they generate a confident-sounding answer anyway. Wrong facts, fake statistics, invented sources. All delivered with a straight face. They don't know your specific sources. Think of a software engineer asking an AI assistant about their company's internal API documentation, deployment runbooks, or architecture decisions. None of that is in the training data. The model has never seen it — and it will still try to answer. The model isn't lying — it's generating the most plausible answer it can. It just has no way to know when it's wrong. So, what do you do when you need an AI that's accurate, current, and knows your specifi

I tested Wispr Flow and various AI-powered transcription software to see whether you should bother subscribing or stick with free services.

Hiring an AI Development Company? Ask These 7 Questions First Most AI projects fail long before deployment. Not because the model is bad. Because teams skip the hard engineering questions. If you're evaluating an AI development company, ask these 7 questions first: 1. How is data secured? AI systems process sensitive business information. Ask: Where is data stored? Is encryption enabled at rest and in transit? Who has access to prompts, logs, and embeddings? Are enterprise security standards followed? Security should be designed in from day one. 2. What observability exists? You can't improve what you can't monitor. A production AI system should include: Request tracing Prompt/version tracking Latency monitoring Cost visibility Error reporting If nobody can explain what happened after a bad output — that's a problem. 3. How do you handle model drift? AI performance changes over time. Questions to ask: How are outputs evaluated? Is feedback collected? How are prompts/versioning managed? What happens when accuracy drops? Production systems need iteration loops. 4. What happens during failure? No system is perfect. Ask: Is there fallback logic? Human review? Retry handling? Graceful degradation? Failure handling matters more than demos. 5. How is access controlled? Enterprise AI systems require permissions. Examples: Role-based access API authentication Audit logs Team-level controls Not everyone should access everything. 6. What compliance assumptions exist? Especially important for regulated industries. Ask whether the system considers: GDPR SOC2 HIPAA Financial or internal compliance rules Compliance cannot be an afterthought. 7. Who owns the infrastructure? Clarify ownership before signing anything. Ask: Who owns the source code? Cloud infrastructure? Models and prompts? Data pipelines? You should avoid vendor lock-in. AI success is rarely about flashy demos. It's about secure infrastructure, reliability, observability, and long-term maintainability. What question

GitHub reports cutting token costs in agentic CI workflows by up to 62% by pruning unused MCP tools, swapping some MCP calls for gh CLI, and running daily “auditor” and “optimizer” agents. A token-usage.jsonl artefact and an Effective Tokens metric help track spend across models and spot regressions. By Mark Silvester

Agentic AI coding tools are transforming how we build software. But they share a fundamental constraint: context windows are finite, and as chat sessions grow, AI performance degrades, a phenomenon Anthropic calls context rot . The model loses its grip on early instructions, leading to a frustrating "fix-it loop" where the agent fixes one thing but breaks another. Most of us prompt an agent, let it write code, review it, and repeat. This works beautifully for prototypes. But when you need to build a stable, full-featured product with hundreds of mission-critical acceptance criteria (AC), "vibe-coding" breaks down. The reality is that you get better behavior from agents the same way you get it from humans, by explicitly capturing what good and bad look like, and checking against it . Coming from a systems engineering background in regulated industries, I knew we needed to stop treating agents like conversational chat buddies and start treating them like engineering assets. That's why I built DevCortex : a purpose-built structured intelligence layer that brings systems engineering discipline to agentic workflows. What is DevCortex? DevCortex is an agentic development platform built on one core idea: AI agents work best when they have structured, queryable access to a database of requirements they can interrogate on demand, not a wall of text in a prompt. It sits between the human specification and AI execution using three components: 1. An Agentic-V Model Database: A structured hierarchy mapping your high-level vision (ConOps) to system specs (Specs), individual requirements (Reqs), linked defects (Issues), and an auto-generated Traceability Matrix. 2. An MCP Server: Delivers just-in-time, high-signal context to tools like Claude Code or Open Code. Instead of dumping requirements upfront, the agent queries exactly what it needs, when it needs it. 3. Human Control Planes (Web UI & CLI): A multi-user Web UI with real-time WebSocket feeds to watch your agent work, plus a

Most software projects focus on producing outputs. Most AI projects focus on producing predictions. But real organizations don't operate on outputs or predictions alone. They operate on decisions. A decision has consequences. A decision creates risk. A decision consumes resources. A decision changes the future state of a system. Over the last few months, I've been studying and building systems around a simple question: How can we make decisions more explainable, auditable, and repeatable? This led me toward concepts such as: event-driven architectures decision logging risk evaluation pipelines audit trails feedback loops operational intelligence systems Instead of asking: "Can we predict what will happen?" I'm becoming more interested in asking: "Can we explain why a decision was made?" and "Can we reproduce that decision six months later?" Current areas I'm exploring: Financial decision systems Risk infrastructure Event-driven architectures Blockchain compliance workflows Operational intelligence platforms One of the projects I'm currently building is an Event-Driven Decision Logging System (EDDL), designed to explore how organizations can record, audit, and replay critical decisions over time. Still learning. Still building. Still refining my understanding of how complex systems operate under uncertainty. Looking forward to sharing the journey here. systemsdesign #architecture #backend #fintech #softwareengineering #eventdriven #riskmanagement

Everyone can build it. Almost no one can afford to run it at scale. And the companies selling the picks and shovels are about to get undercut by the same forces they unleashed. by VEKTOR Memory — 20 min read How This Article Started: 20 Forums, 40 Headlines, and a Growing Sense That Everyone Was Confused I woke up to clear skies and the sun finally shining, and I set out to understand this idea, the truth behind it, and the nagging suspicion that the narrative around AI and software costs had become so loud, so uniform, and so confidently confusing that someone needed to sit down and actually go through it. No tweets, or are they now X's? No LinkedIn thought leader infomercials, no Substack hype, just actual research and deep thoughts. So I spent time reading, collating data. Forums, whitepapers, LinkedIn posts, Hacker News threads, VC essays, Reddit arguments. I went looking for the real signal underneath the noise. What I found instead was the full spectrum of human overconfidence, lots of moat real estate. On one end: the hype machine at full throttle. “Software is going to zero.” “A solo dev can now build what a 50-person team built in 2021.” “The era of the $500/month SaaS subscription is over.” “Vibe coding will replace your entire engineering org.” These headlines were everywhere. Breathless. Confident. Shared tens of thousands of times, this angle gets views, of course, the algorithm loves being fed claps, shares, comments, and reposts. Most were written by people who had a very good Tuesday with Codex, Windsurf, Claude and Cursor and decided that instant dev, open source to Github and getting oodles of stars, maybe even roping in a celebrity, was now the permanent condition of software development. “We are now famous on GitHub!" Very hipster, very vibes, see you on the playa.. On the other end: the backlash. Experienced engineer, people with 15 to 25 years in production systems are pushing back hard. “Show me the vibe-coded app that survived its first real