featured articles
Before the Code. In the Code. After the Code. Security in the age of AI Factories
Software development didn't just get faster. It broke shape. The old shape of plan, design, build, test, deploy is not how software gets built anymore. Now it is specs in one place, prompts in another, code written by humans and agents, architecture decisions made in a chat window, and tests generated after the fact.
The boundary around who builds is dissolving too. Engineers orchestrate agents. Product managers turn ideas into real products with the help of vibe coding. Business Analysts build workflows that touch real data and real systems. Some of it enters the formal SDLC. Some never do. All of it changes the attack surface.
The end state is becoming obvious: software factories run mostly by agents, the way lights-out factories run manufacturing lines with no humans on the floor. Some companies are already there. Most are in the awkward middle - partial adoption, uneven quality, and pressure to move faster anyway.
Strip away the noise and the goal is simple: whatever reaches production has to be secure and follow the rules you set for it. That job did not change. Everything around it did.
Shift left and DevSecOps were the right answers for their moment - but both were designed around developers making decisions. Now agents make architectural choices, wire data flows, and push work forward faster than any human checkpoint can follow. Every prompt, every PR, every agent-generated feature is an architectural decision your security team never reviewed.
The next model is not a faster human. It is an autonomous security agent operating in the same environment as the development agents - and it cannot work component by component. Attackers already don't: AI-powered attack tooling chains the design flaws, code vulnerabilities, and cloud misconfigs your agents just introduced into single exploitable paths. Scanners see files. Pipelines see changes. Attackers see weaknesses - and need only one that connects. Security has to see the product - that is where weaknesses connect: what is being planned, what is in work, and what has shipped.
That is what Product Security means now. Not security embedded in a pipeline - security as an autonomous participant in it, holding the product view through every stage: before the code, in it, and after it.
Before the code - where intent gets set and attack vectors get introduced
For business critical features and complex systems, design still deserves real scrutiny before a single line gets written. An agent factory executing a flawed design quickly is worse than a slow team building the wrong thing manually. The blast radius is bigger. A missing auth requirement, a broken tenant isolation model, an exposed data flow - these are not code problems. They are design decisions, and agents execute them at speed.
As spec-driven development matures, getting the spec right becomes the highest-leverage security investment you can make. The old way of getting it right was threat modeling - a workshop, a whiteboard, an architect asking the right questions. It worked, for the handful of features that got one. That trade dies when a product manager's spec becomes running code in a day. Autonomous review changes the economics: it reads every spec, ticket, and PRD as it is written - wherever intent lives - and asks what the architect would have asked.
What the design stage gives you is the missing context: what the feature is meant to do, who should reach it, what data it touches, and what it must never allow. Without that, the check after the code can only answer one question: is this vulnerable? With it, it can answer the ones that actually drive a decision: does this vulnerability matter, what does it cost the business, and is this what was supposed to get built?
Design is still where security starts. It is no longer where it stops. The review does not produce just a report. It produces the context the next stage runs on.
In the code - security cannot just guide agents. It has to act.
Prompts change. Models change. Agents change. The system is what accumulates - every architecture decision, every trust boundary, every data flow, every intent, layered over years. Without that context, a security agent can reason about code. With it, it can reason about the system.
Security has two jobs here: steer the work while it is written, and gate it before it merges.
Steering happens in the moment. A development agent starts wiring a new data flow - the security agent loads the live architecture, reads the trust boundaries, and if something is wrong, intervenes. Not a flag. Not a ticket. An agent with the authority to block a bad decision before it is ever committed.
The gate is the pull request - the last moment a change is still just a proposed change. Everything gets checked, every time, no matter who or what wrote the code. The gate answers one question: does this change violate a rule you already set? Hardcoded secrets, broken cryptography, and prohibited patterns do not require system-wide reasoning. They are known violations and should be stopped immediately. That is what makes the gate fast, deterministic, and difficult to argue with. Exploitability is a different question.
The PR merges. The change becomes part of the system. And exploitability lives in the system, not the diff.
After the code - where exploitable paths get validated
The change has landed. It is part of a system now. Whether it is exploitable is no longer a fact about the change - it is a fact about the system around it. The gate answered one question: did you break a rule. This stage answers the other: is there a path to exploit. The analysis starts the moment the change lands, before anything ships, and it never stops after.
First, at the repo level. A flagged line of code matters only if it plays a part in an attack path - as the way in, or as a step along the way - past the controls that exist. A vulnerable dependency only matters if the vulnerable function is reachable and exploitable with input an attacker controls. Part of no path is noise. That is how the 200-issue queue dies - validation eliminates the 195 that never mattered and confirms the five that did.
Then at the system level, continuously. Clean when it landed does not mean clean today: a new CVE drops against a dependency you merged six months ago, a cloud config drifts, another team's change opens a path through your service. The attacker does not care which PR introduced which piece - only whether a path exists through the system as it runs right now.
You hold the source, the architecture, the cloud controls, and the intent behind every feature - everything an attacker wishes they had, and you have it first. Run the real thing from the inside: continuous, white-box attack path analysis across the live system. An internal service skips authentication because nothing external can reach it. An agent builds on its API, a routing change exposes it - zero findings, one path to customer data. Only the intent recorded on day one makes the last change light up.
Not is this vulnerable - a scanner guesses at that. Is there an exploitable path, through this architecture, past these controls, into this data. You do not infer it. You validate it. The output is not a list of findings. It is a path an attacker can take, end to end.
–
The challenge has shifted. It is no longer "How do we find bugs earlier?" It is "How do we release secure software when the decisions that matter are made autonomously, continuously, and faster than any human review can follow?" That question does not have a checkpoint answer. Security cannot review decisions after they are made. It has to participate in them as they happen.
And participation is not three products at three checkpoints. It is one view of the product - planned, in work, shipped. The intent understood before the code is what makes steering possible during it, and what makes validation credible after it. Break that chain into point tools and each sees a slice; the exploitable path that matters often spans all three. That is not another scanner or another policy engine. It is a new operating model for Product Security.
We built Prime to run that model.
Before the code, it reviews design intent autonomously and records what every feature is supposed to do. In the code, it steers agents and developers with the live architecture loaded, and gates every PR on the rules you set. After the code, it validates exploitable paths continuously across the live system.
This only works as one platform. Prime can validate an exploitable path because it understood what the feature was supposed to do before the code existed, followed how it was implemented, and sees how the system and its controls connect today. That context cannot be reconstructed reliably after the fact. It has to persist from intent through implementation.
The factory is already running. Security can review its decisions after they happen, or participate in them as they are made. We built Prime for the second answer. Before the code. In the code. After the code.
.avif)
The Most Ignored Artifact in Security is Now the Most Important One
Security policies were the documents nobody read. Written, published, forgotten. Developers worked around them. Security teams rewrote them every two years and called it progress. Everyone understood the game and nobody said anything because it was mostly harmless. A bad policy sat in a wiki somewhere and collected dust.
That is no longer the situation.
In an agentic world the agent does not work around the policy. It follows it. Every time. No judgment, no improvisation, no common sense filling the gaps. That changes what a bad policy costs, in a way most security teams have not fully sat with yet.
A bad policy written for humans is a document nobody reads. Mostly harmless because humans ignored it anyway. A bad policy followed by agents is consistent wrong behavior, at scale, across everything your agents touch. It does not sit in a document anymore. It ships.
Here is what that looks like in practice. A policy that says "use appropriate encryption" is standard language in half the security documents written in the last decade. It tells a human to think and make a reasonable call. It tells an agent to decide. It will decide. It might pick MD5. It will be consistent about it.
The language that felt precise enough for a human audience, "appropriate," "reasonable," "where possible," is not precise at all. It is an instruction to exercise judgment. Rewriting policies for agents forces decisions that security teams have been deferring for years. What does appropriate encryption actually mean in this system? What counts as sensitive data in this context? What should the agent never do, regardless of what it is asked? These questions used to live in someone's head. Now they have to be written down in a form a machine can execute without a human in the loop to catch the edge cases.
The difference in practice looks something like this. The old version says "use appropriate encryption for sensitive data." The new version says "all data classified as sensitive must be encrypted using AES-256-GCM at rest and TLS 1.3 in transit. The agent must not proceed if either condition cannot be verified." One requires a judgment call. The other does not. If you cannot write a test that verifies the agent followed the policy, the policy is not done.
There is one more thing the static policy model never had to confront. The threat landscape does not wait. When a new attack technique gets published, the window between disclosure and active exploitation is sometimes days. A policy that was correct last month can be the thing that gets you next month. Human security teams absorbed that kind of change through awareness, the engineer who read the advisory and updated the standard before it mattered. Agents do not read advisories. They follow what they were given. A policy that cannot be updated dynamically and propagated to every agent consuming it in real time is already becoming a liability the moment it is written. Specificity and machine readability make agent-ready policy powerful. They also make it brittle if the update mechanism is not part of the design from the start.
That is a pipeline problem as much as a content problem. The policy layer has to be live. Version controlled, continuously updated against the current threat landscape, and connected to the agents consuming it in a way that does not require a manual deployment every time something changes. That is new infrastructure most security teams do not have yet and are not building.
That is usually how it goes right before something forces it.
Do it before the agent does something your policy technically allowed.
Preparing Security for the Day of Zero-Touch Development
The security industry has spent three years moving the line.
Code completion would not work, then it did. AI-generated features were off the table, too much state, too much domain knowledge, until that ceiling moved too. At some point this stops being analysis and starts being denial. Full application generation is not a question of if.
To be fair, security people are trained skeptics. Questioning things that seem too easy is the job, and that instinct is usually right. The problem is that the same quality that makes a good security professional, a deep distrust of anything that looks too clean, made this genuinely hard to see coming. The reflex was correct. The situation was just different this time. It happens.
So the question now is whether security is ready. The honest answer is no, and the reason is not what most people assume.
Security was not just built around humans. It was built around human behavior. The invisible judgment calls that happen between a design review and a code review. The developer who remembers what got flagged last sprint. The architect who quietly connects a vulnerability report to the decision that caused it six months earlier. None of that is written down anywhere. It lives in people's heads, and it has for years, because it worked well enough. In most organizations there is a senior engineer who every payments-related finding gets quietly routed to before triage, not because any process says so, but because she is the only one who remembers why a particular call was made in 2019 and what breaks if you touch it. That knowledge is not in any system. It is in her calendar.
Zero-touch development removes those people before most security programs have captured what they know. A dev agent can carry security context, if that context exists somewhere it can reach. The risk is not that agents are blind by nature. It is that most security guidance today is not documented in any form an agent can consume. It is institutional knowledge inside humans who are about to be removed from the loop.
The tools are not too slow. They are islands, and the human who connected them is leaving.
This is the work that has to start now. Not procuring new platforms. Capturing what security teams already know and putting it somewhere agents can actually reach, policy encoded in the pipeline, threat models that live in the repo, guardrail rules derived from the organization's own findings rather than generic frameworks. The difference between an agent that ships secure code and one that does not is almost never the model. It is whether the guidance was there in the first place.
MCP changes something more fundamental than integration. APIs existed before and teams built connectors, but every connection was a custom project, owned by someone, maintained by someone, and when that someone left it quietly broke. MCP makes the connectivity layer a shared standard rather than a collection of bespoke plumbing, so the loop stays closed without a human constantly holding it together. But the architecture is only as good as what goes into it. Connectivity does not fix a documentation problem. Those are two different problems and it is worth being clear about which one you are solving.
The policy layer behind all of this cannot sit in AppSec alone. AppSec owns the enforcement and the enablement, the guardrails, the pipeline controls, the agent-level guidance. But the policy itself has to be built across security, engineering and GRC together. That is not a coordination challenge to be managed. That is the actual work.
The window is open right now. Once zero-touch development is fully running, retrofitting security guidance into a process already operating without it is slower, more expensive and always one step behind. The teams doing this work today are not just getting ahead of a trend. They are building the institutional memory their agents will run on.
The ones waiting are not just behind. They are losing the people who know the things that cannot be recovered.
.avif)
Security Design Reviews vs. Threat Modeling (April 2026)
The Nuances of Design Stage Security
If you work in cybersecurity (or security adjacent) you are very familiar with the 2 main practices that help to identify and remediate security concerns before development starts; Threat modeling and Security Design Reviews. Both are practical capabilities, and while threat modeling has a variety of frameworks, design reviews are more of a delicate and tactical process that heavily relies on an intimate knowledge of the business. But have you ever felt like your security reviews are missing the mark? Maybe they’re too generic or don’t account for the unique risks your business faces. The challenge often lies in capturing that elusive business context. While threat modeling is a powerful tool, it often happens to be a hammer, and so reluctantly security has to see every design problem as a nail. This makes threat modeling a default approach even when a more nuanced method, like targeted security reviews, would be more effective. By harnessing Large Language Models (LLMs) to sift through unstructured data, we can finally bring the vital context needed to scale security reviews across the board and provide a supercharged version of this method to security practitioners.
Context: The Critical Factor
Traditional security checks often fall short because they can’t adapt to the specific nuances of your business, and threat modeling alone can’t address all the intricacies of secure development. This is where LLMs come into play. By leveraging new LLM empowered capabilities early in the design stage of the SDLC, we can enhance security reviews with deeper context and precision, making them more effective and efficient. This approach allows you to weave security into your systems right from the start, rather than relying on exhaustive modeling for every scenario.
Providing developers with business-driven, concrete security requirements upfront reduces friction and ensures the right tools are used at the right time. By leveraging security reviews at scale for ongoing, contextual feedback, development teams know exactly what’s expected before writing a single line of code, minimizing rework and keeping projects on track. It substantially reduces the dependency on sometimes very cumbersome threat modeling processes that can be an overkill for the task at hand.
Prime Security: Embedding Security before Development starts
At Prime, we focus on security design reviews because we know they’re the most practical and proactive way to secure products from the ground up. By providing the infrastructure to capture and integrate business context, Prime ensures that your security reviews are tailored to the specific needs of your organization. The result? A product that’s secure by design, allowing your teams to move fast without sacrificing security.
.avif)
Product Velocity is Dependent on Product Security
The Cost of Security Stepping in Too Late
It’s a common problem: product development is moving fast, but once security steps in late, everything slows down. As companies grow and products become more complex, security often gets pushed to the end of the process. By then, code is written, deadlines are looming, and vulnerabilities surface. The result? Expensive delays and missed opportunities:
- Development teams scramble to rework code, adding up to 40% more time to the release cycle.
- Release schedules slip, increasing operational costs by 20-30%.
- Customers grow frustrated as features are delayed, leading to negative feedback.
- The relationship between Security and Engineering becomes strained, slowing progress even further.
This isn’t just frustrating—it’s costly. Fixing security issues late in the process can cost up to 10 times more than addressing them earlier. The core issue? Security and engineering aren’t working together early enough.
It's a People, Process, and Technology Problem
Today, companies rely on traditional security processes such as Security Design Reviews, Threat Modeling, and Security Champions programs to bridge the gap between Security and Engineering. According to the SANS DevSecOps Survey, most organizations recognize the value of up-front risk assessments, with over 80% of respondents acknowledging the benefits of early security involvement. However, few consistently implement these assessments early in the development process.
Why? It’s not just a technology issue—it’s a people and process problem too. Security design reviews and threat modeling are often manual, time-consuming, and difficult to scale across fast-moving development cycles. Programs like Security Champions, while valuable in theory, suffer from inconsistent adoption and execution, leaving critical gaps that can be costly to address later.
In a world where businesses need to move quickly to stay competitive, relying on manual, late-stage security processes becomes a significant bottleneck. Addressing vulnerabilities during the design phase is up to 10x cheaper and 70% faster than fixing them post-release. For organizations that rely on fast, iterative releases, every delay can compound, affecting market share, customer satisfaction, and overall growth.
Prime Security’s Approach
At Prime Security, we focus on maintaining product velocity by seamlessly integrating security into the planning and design phases, without disrupting existing workflows. Our platform connects directly with your company’s development tools—like Jira and Confluence—so security becomes part of the process without requiring developers to change their behavior. By automating the identification of risks and providing full visibility into potential issues before any code is written, Prime Security enables teams to take a preventative approach, addressing critical concerns early and keeping development on track. Rather than overwhelming developers with complex security tasks, we simplify the process by offering clear, actionable insights that allow Security and Engineering to collaborate efficiently. Prime Security delivers immediate time-to-value, with actionable insights available within 24 hours of implementation, ensuring teams can avoid last-minute delays and keep the development pipeline running smoothly.
Final Thoughts
When security is left to the end of the development process, product velocity inevitably suffers. But when Security and Engineering collaborate from the start, teams can avoid delays, meet their deadlines, and deliver secure, reliable products faster. By embedding security in the design phase, companies not only prevent costly delays but also gain a competitive advantage by consistently delivering secure, high-quality products at speed. At Prime Security, we help companies shift security left, empowering teams to move quickly without sacrificing security.
.avif)
.avif)
.avif)
Building Prime Security
As security professionals and technical leaders we’ve experienced the main pain in developing products. The constant struggle of balancing development velocity with security needs. Through it all, one thing became clear, many security challenges could be prevented given the right context at the design phase of the SDLC. Too often, security comes in at the last minute, scrambling to apply fixes after development is complete, leaving both teams frustrated and out of sync.
Sure, security exists in the SDLC today, but it starts to scale when code is written. You can scan for dependencies, catch bugs, and identify vulnerabilities. But Product Security shouldn’t start with code scanning; it needs to start with design. It’s not just about applying processes or enforcing policies; it’s about influencing decisions before a single line of code is written. Security teams need actionable insight into what’s being built and why, from the earliest stages. But extracting that insight is challenging, scaling it across fast-paced teams is even harder, and making it stick while everyone’s sprinting to meet deadlines can feel nearly impossible.
That’s why we built Prime Security. To truly integrate security into modern development, it has to start at the design phase, not after. We’re not here to slow development down; we’re here to give security engineering teams superpowers so they can support developers to make smarter decisions, faster - embedding security directly into their workflows.
With our unique business and security context extraction engine, Prime Security automates risk assessments and generates tailored mitigation recommendations, ensuring that security isn’t just an afterthought, but a partner in the development process. Prime brings hard-won insights from security professionals right to the point where they’re needed most. This isn’t about adding friction; it’s about unlocking development velocity without compromising on security.
This is the future of Product Security: practical, scalable, and context-driven decisions, integrated from day one. With Prime, security and development teams can truly build securely from the start, setting a new standard for scalable, design-first security. We’ve lived through these challenges, and we’re here to solve them, for good.
Michael, Dimitry, Danny, Matan
