AI in Coding and Development

Anthropic 𝗷𝘂𝘀𝘁 𝗿𝗲𝗹𝗲𝗮𝘀𝗲𝗱 𝗮 𝗱𝗲𝗻𝘀𝗲 𝗮𝗻𝗱 𝗵𝗶𝗴𝗵𝗹𝘆 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗮𝗹 𝗿𝗲𝗽𝗼𝗿𝘁 𝗼𝗻 𝗵𝗼𝘄 𝘁𝗼 𝗯𝘂𝗶𝗹𝗱 𝗲𝗳𝗳𝗲𝗰𝘁𝗶𝘃𝗲 𝗔𝗜 𝗮𝗴𝗲𝗻𝘁𝘀 — 𝗽𝗮𝗰𝗸𝗲𝗱 𝘄𝗶𝘁𝗵 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗶𝗻𝘀𝗶𝗴𝗵𝘁𝘀 𝗳𝗿𝗼𝗺 𝗿𝗲𝗮𝗹-𝘄𝗼𝗿𝗹𝗱 𝗱𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁𝘀: ⬇️ Not just marketing, BUT a real, practical blueprint for developers and teams building AI agents that actually work. It explains how Claude Code (tool for agentic coding) can function as a software developer: writing, reviewing, testing, and even managing Git workflows autonomously. BUT in my view: The principles and patterns described in this document are not Claude-specific. You can apply them to any coding agent — from OpenAI’s Codex to Goose, Aider, or even tools like Cursor and GitHub Copilot Workspace. 𝗛𝗲𝗿𝗲 𝗮𝗿𝗲 7 𝗸𝗲𝘆 𝗶𝗻𝘀𝗶𝗴𝗵𝘁𝘀 𝗳𝗼𝗿 𝗯𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗯𝗲𝘁𝘁𝗲𝗿 𝗔𝗜 𝗮𝗴𝗲𝗻𝘁𝘀 — 𝘁𝗵𝗮𝘁 𝘄𝗼𝗿𝗸 𝗶𝗻 𝘁𝗵𝗲 𝗿𝗲𝗮𝗹 𝘄𝗼𝗿𝗹𝗱: ⬇️ 1. 𝗔𝗴𝗲𝗻𝘁 𝗱𝗲𝘀𝗶𝗴𝗻 ≠ 𝗷𝘂𝘀𝘁 𝗽𝗿𝗼𝗺𝗽𝘁𝗶𝗻𝗴 ➜ It’s not about clever prompts. It’s about building structured workflows — where the agent can reason, act, reflect, retry, and escalate. Think of agents like software components: stateless functions won’t cut it. 2. 𝗠𝗲𝗺𝗼𝗿𝘆 𝗶𝘀 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 ➜ The way you manage and pass context determines how useful your agent becomes. Using summaries, structured files, project overviews, and scoped retrieval beats dumping full files into the prompt window. 3. 𝗣𝗹𝗮𝗻𝗻𝗶𝗻𝗴 𝗶𝘀𝗻’𝘁 𝗼𝗽𝘁𝗶𝗼𝗻𝗮𝗹 ➜ You can’t expect an agent to solve multi-step problems without an explicit process. Patterns like plan > execute > review, tool use when stuck, or structured reflection are necessary. And they apply to all models, not just Claude. 4. 𝗥𝗲𝗮𝗹-𝘄𝗼𝗿𝗹𝗱 𝗮𝗴𝗲𝗻𝘁𝘀 𝗻𝗲𝗲𝗱 𝗿𝗲𝗮𝗹-𝘄𝗼𝗿𝗹𝗱 𝘁𝗼𝗼𝗹𝘀 ➜ Shell access. Git. APIs. Tool plugins. The agents that actually get things done use tools — not just language. Design your agents to execute, not just explain. 5. 𝗥𝗲𝗔𝗰𝘁 𝗮𝗻𝗱 𝗖𝗼𝗧 𝗮𝗿𝗲 𝘀𝘆𝘀𝘁𝗲𝗺 𝗽𝗮𝘁𝘁𝗲𝗿𝗻𝘀, 𝗻𝗼𝘁 𝗺𝗮𝗴𝗶𝗰 𝘁𝗿𝗶𝗰𝗸𝘀 ➜ Don’t just ask the model to “think step by step.” Build systems that enforce that structure: reasoning before action, planning before code, feedback before commits. 6. 𝗗𝗼𝗻’𝘁 𝗰𝗼𝗻𝗳𝘂𝘀𝗲 𝗮𝘂𝘁𝗼𝗻𝗼𝗺𝘆 𝘄𝗶𝘁𝗵 𝗰𝗵𝗮𝗼𝘀 ➜ Autonomous agents can cause damage — fast. Define scopes, boundaries, fallback behaviors. Controlled autonomy > random retries. 7. 𝗧𝗵𝗲 𝗿𝗲𝗮𝗹 𝘃𝗮𝗹𝘂𝗲 𝗶𝘀 𝗶𝗻 𝗼𝗿𝗰𝗵𝗲𝘀𝘁𝗿𝗮𝘁𝗶𝗼𝗻 ➜ A good agent isn’t just a wrapper around an LLM. It’s an orchestrator: of logic, memory, tools, and feedback. And if you’re scaling to multi-agent setups — orchestration is everything. Check the comments for the original material! Enjoy! Save 💾 ➞ React 👍 ➞ Share ♻️ & follow for everything related to AI Agents!

RIP coding? OpenAI has just introduced Codex — a cloud-based AI agent that autonomously writes features, fixes bugs, runs tests, and even documents code. Not just autocomplete, but a true virtual teammate. This marks a shift from AI-assisted to AI-autonomous software engineering. The implications are profound. We’re entering an era where writing code can be done by simply explaining what you want in natural language. Tasks that once required hours of development can now be executed in parallel by an AI agent — securely, efficiently, and with growing precision. So, what does this mean for human skills? The value is shifting fast: → From execution to architecture and design thinking → From code writing to problem framing and solution oversight → From syntax knowledge to strategic understanding of systems, ethics, and user needs As Codex and other agentic AIs evolve, the most critical skills will be, at least for SW tech roles: • AI literacy: knowing what agents can (and cannot) do • Prompt engineering and task orchestration • System design & creative problem solving • Human judgment in code quality, security, and governance It’s a new world for solo founders, tech leads, and enterprise innovation teams alike. We won’t need fewer people. We’ll need people with new skills — ready to lead in an agent-powered era. Let’s embrace the shift. The real opportunity isn’t in writing code faster — it’s in rethinking what we build, how we build, and why. #AI #Codex #FutureOfWork #SoftwareEngineering #AgenticAI #Leadership #AIAgents #TechTrends

I recently sat down with Erran Berger, VP of Product Engineering at LinkedIn, to discuss a question that’s on every developer’s mind: How is AI actually changing the way we build software? We’re moving past the "AI will write all the code" hype and into a much more interesting reality. The role of the software engineer isn't disappearing; it’s being elevated. 🤌 TL;DR from the conversation: 1/ Systems Thinking > Syntax: As AI handles more of the boilerplate, the value of an engineer shifts toward orchestration and high-level architecture. 2/ The "Human Editor": AI can generate solutions, but human judgment remains the final (and most critical) line of defense for security, ethics, and performance. 3/ Solving Technical Debt: One of the most exciting use cases Erran shared was using AI to refactor legacy systems—turning a months-long headache into a manageable project. 4/ New Must-Have Skills: If you aren't already looking into RAG, LLMOps, and Vector Databases, now is the time to start. The goal isn't just to write code faster; it's to make engineering "joyful" again by removing the friction and focusing on pure problem-solving. Watch the full episode here: https://lnkd.in/gEJb4jdz Thank you, LinkedIn team for inviting me over, for this incredibly insightful conversation 🫶

I was convinced AI would transform how we build software. I did not expect it to happen so fast. Over the past year, through conversations with leaders like Thomas Dohmke, startups in the AI software development space, working with the Anthropic team, and observing our own builders at Doctolib, one thing has become clear to me. AI is changing how we think about building software like nothing before. Specs turn into working prototypes instantly. Design systems and architecture principles are continuously reinforced by the tooling itself. Writing production-ready code from scratch is no longer our bottleneck. Tests are generated automatically to validate intent. Complex refactoring is handled by autonomous agents. And this is accelerating. As Ethan Mollick once said: "The AI we use today is the worst AI we will ever use.” Better models enable more capable agent fleets and higher autonomy, which in turn drive even better models As tech builders, our day-to-day job is changing… We don’t focus as much on manual implementation, writing boilerplate, or debugging line by line. Instead, we design the systems and scaffolding that allow AI to do reliable work. We orchestrate agents with the right intents, we validate AI-generated architectures, and we define strict quality guardrails. ….but the outcome doesn’t change: creating better technologies for our users. This is a strong opportunity for all tech companies to innovate faster, but for us even more so in view of the specificities of healthcare and the quality of our technologies and teams. 🔹 AI will help us create more value for our health professionals and anyone managing their health. 🔹 AI will help us tackle all user feedback, bugs and incidents in minutes. 🔹 AI will make us launch more specialties and more countries faster. At Doctolib, we're going all-in on this transformation. Dozens of specialized agents deployed. Our engineering leaders are driving this change, committing code 5x more frequently than a year ago. Teams already deliver significantly more value to patients and health professionals. If you want to join that revolution and contribute to reinventing the daily life of health professionals and improving health for everyone, we welcome all builders. It's only the beginning.

97% of orgs faced AI breaches in 2025 had zero access controls in place. Not weak; Not outdated controls. Zero [Source: IBM] Meanwhile, 35% of real-world AI security incidents came from simple prompts some causing $100K+ in losses without a single line of code [Source: Adversa] The gap between AI deployment speed and security implementation is only widening. Hence I am sharing 10 security checkpoints every AI agent needs before touching production systems: ✅ Output Validation → Middleware that verifies decisions against rules before execution. Traffic lights for AI actions. ✅ Access Control → Least privilege enforcement. Role-based permissions that limit what agents can touch. ✅ Credential Safety → Secrets management that keeps API keys away from prompts and logs. Store them like vault keys, not sticky notes. The other 7 checks are in the carousel including rate limiting that prevents runaway loops and human approval for high-stakes decisions 👇 Most teams rush deployment. Security becomes an afterthought until something breaks. Tell me your story: what security measure has prevented a disaster in your AI system? Follow me, Bhavishya Pandit, for practical AI production insights from the trenches 🔥 #ai #security #agents

Let's cut to the chase: GenAI project complexity can quickly spiral out of control. Here's a project structure that keeps things clean, maintainable, and scalable: Key components and their benefits: 1. Modular 'src/' Directory: - Separates concerns: prompts, LLM integration, data handling, inference, utilities - Enhances code reusability and testing - Simplifies onboarding for new team members 2. 'configs/' for Environment Management: - Centralizes configuration, reducing hard-coded values - Facilitates easy switching between development, staging, and production environments - Improves security by isolating sensitive data (e.g., API keys) 3. Comprehensive 'tests/' Structure: - Distinguishes between unit and integration tests - Encourages thorough testing practices - Speeds up debugging and ensures reliability, crucial for AI systems 4. 'notebooks/' for Experimentation: - Keeps exploratory work separate from production code - Ideal for prompt engineering iterations and performance comparisons 5. 'docs/' for Clear Documentation: - Centralizes key information like API usage and prompt strategies - Crucial for maintaining knowledge in rapidly evolving AI projects This structure aligns with the principle "Explicit is better than implicit." It makes the project's architecture immediately clear to any developer jumping in. Question for the community: How do you handle versioning of models and datasets in your AI projects?

Will #AI #replace software #engineers? Top engineers are paid not for their ability to script (to express themselves in code) but for their ability to understand the architecture of software systems and to write the kind of code that plays nicely with the rest of their organization’s complex codebase. They know that their work is more than simply translating their thoughts into a programming language, it’s about understanding the implications of their technical choices. While AI will effectively automate the former, automating the latter is a tall order. Here's my answer, along with others, featured in this ZDNET piece: https://bit.ly/zdnet_swes LLM coding assistants can't guarantee 100% reliable results. The 'generative' in GenAI means the output is randomly sampled from a distribution of likely responses based on your prompts. So you can get endless answers to the same question—some helpful, others far off the mark. Commercial #LLMs have some error-checking under the hood, but it's not bulletproof. Even human experts can’t guarantee perfect results, which is why organizations keep someone on call around the clock to fix problems and respond to system outages. But anticipating the consequences of code you wrote is often easier than anticipating the consequences of AI-generated code. Expect more surprises, less reliability, and more technical debt as more code is written by AI agents without human oversight. Where performance matters, software engineering agents are unlikely to eliminate the work—they’ll just shift it from writing the code to explaining and reviewing it, which isn't always a win. Engineers will find themselves playing archeologist in the AI’s mistakes. Most coders will tell you it's far more fun and fulfilling to write code yourself than read someone else's. AI-generated labor at scale sounds great on paper, but someone will still need to monitor the bots, fix their mistakes, evaluate edge cases, maintain long-term systems, and ultimately take responsibility. 🍼 Unless we're careful, we risk replacing builders with babysitters. It's up to us how that plays out. 🍼 My advice to software engineers is threefold: 1) Double down on precise thinking. Whether prompting or coding, the key skill is explaining your wishes to the machine in the way that gets you the most reliable outcome. 2) Become an expert in complex systems. Agent-generated software will dramatically increase the complexity of the systems you’ll be architecting solutions for, so tomorrow’s engineering challenges will be harder than today’s. 3) Work on human skills that bots can’t replace: sound decision making, the mental agility to adapt to rapidly changing technologies, the critical thinking frameworks needed to complement AI insights, and a deep understanding of systems architecture. Please ✨ repost ✨ so the message doesn't vanish in the abyss of social media... subscribe to my newsletter at https://lnkd.in/ePiCimXg

AI-assisted coding isn’t just about autocomplete anymore. It’s becoming a full lifecycle - from planning to building to reviewing. Developers are no longer just writing code, they’re orchestrating systems of agents that generate, test, and refine it. The shift is from “write code faster” to “build and ship systems end-to-end.” Here’s how the generative programmer stack is evolving 👇 𝗕𝗨𝗜𝗟𝗗 - 𝗖𝗼𝗱𝗲 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝗼𝗻 & 𝗘𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 Full-Stack App Builders: Turn ideas into working applications quickly by generating frontend, backend, and integrations in one flow. CLI-Native Agents: Work directly from the terminal to generate, edit, and execute code with tight control and speed. IDE-Native Agents: Integrate inside development environments to assist with coding, debugging, and real-time suggestions. Async Cloud Coding Agents: Run tasks in the background - writing, testing, and iterating on code without blocking your workflow. 𝗣𝗟𝗔𝗡 - 𝗣𝗹𝗮𝗻𝗻𝗶𝗻𝗴 & 𝗙𝗲𝗮𝘁𝘂𝗿𝗲 𝗕𝘂𝗶𝗹𝗱𝗶𝗻𝗴 Spec-first Tools: Start with structured specifications that define what to build before writing any code. Ask / Plan Modes: Break down problems, explore approaches, and validate logic before jumping into implementation. Design-to-Code Inputs: Convert designs or structured inputs into working code, reducing manual translation effort. 𝗥𝗘𝗩𝗜𝗘𝗪 - 𝗥𝗲𝘃𝗶𝗲𝘄, 𝗧𝗲𝘀𝘁𝗶𝗻𝗴 & 𝗩𝗲𝗿𝗶𝗳𝗶𝗰𝗮𝘁𝗶𝗼𝗻 Code Review Agents: Automatically analyze code for issues, improvements, and best practices before deployment. Testing & Verification: Generate and run tests to ensure reliability, correctness, and stability across different scenarios. Benchmarks: Measure performance and quality using standardized evaluation frameworks. What this means: Coding is shifting from manual effort to guided execution. The developer’s role is moving toward direction, validation, and system design. The edge is no longer just writing better code. It’s knowing how to use these tools together to ship faster and more reliably. Which part of this workflow are you using AI for the most today?

In an era where many use AI to 'summarize and synthesize' to keep up with what's happening, some documents are worth a careful read. This is one. 📕 The OWASP Top 10 for Agentic Applications 2026 outlines the most critical security risks introduced by autonomous AI agents and provides practical guidance for mitigating them. 👉 ASI01 – Agent Goal Hijack Attackers manipulate an agent’s goals, instructions, or decision pathways—often via hidden or adversarial inputs—redirecting its autonomous behavior. 👉 ASI02 – Tool Misuse & Exploitation Agents misuse legitimate tools due to injected instructions, misalignment, or overly broad capabilities, leading to data leakage, destructive actions, or workflow hijacking. 👉 ASI03 – Identity & Privilege Abuse Weak identity boundaries or inherited credentials allow agents to escalate privileges, misuse access, or act under improper authority. 👉 ASI04 – Agentic Supply Chain Vulnerabilities Malicious or compromised third-party tools, models, agents, or dynamic components introduce unsafe behaviors, hidden instructions, or backdoors into agent workflows. 👉 ASI05 – Unexpected Code Execution (RCE) Unsafe code generation or execution pathways enable attackers to escalate prompts into harmful code execution, compromising hosts or environments. 👉 ASI06 – Memory & Context Poisoning Adversaries corrupt an agent’s stored memory, context, or retrieval sources, causing future reasoning, planning, or tool use to become unsafe or biased. 👉 ASI07 – Insecure Inter-Agent Communication Poor authentication, integrity checks, or protocol controls allow spoofed, tampered, or replayed messages between agents, leading to misinformation or unauthorized actions. 👉 ASI08 – Cascading Failures A single poisoned input, hallucination, or compromised component propagates across interconnected agents, amplifying small faults into system-wide failures. 👉 ASI09 – Human-Agent Trust Exploitation Attackers exploit human trust, authority bias, or fabricated rationales to manipulate users into approving harmful actions or sharing sensitive information. 👉 ASI10 – Rogue Agents Agents that become compromised or misaligned deviate from intended behavior—pursuing harmful objectives, hijacking workflows, or acting autonomously beyond approved scope. The OWASP® Foundation has been doing some amazing work on AI security, and this resource is another great example. For AI assurance professionals, these documents are a valuable resource for us and our clients. #agenticai #aisecurity #agentsecurity Khoa Lam, Ayşegül Güzel, Max Rizzuto, Dinah Rabe, Patrick Sullivan, Danny Manimbo, Walter Haydock, Patrick Hall

🧑💻🐢 𝗔𝗜 𝗧𝗼𝗼𝗹𝘀 𝗦𝗹𝗼𝘄𝗲𝗱 𝗗𝗼𝘄𝗻 𝗧𝗼𝗽 𝗢𝗽𝗲𝗻-𝗦𝗼𝘂𝗿𝗰𝗲 𝗗𝗲𝘃𝘀 𝗯𝘆 𝟭𝟵% We all 𝗲𝘅𝗽𝗲𝗰𝘁 AI to 𝗯𝗼𝗼𝘀𝘁 productivity. But what happens when you rigorously test that assumption in the wild, with real code and experienced devs? A recent RCT (randomized controlled trial) study from METR (Feb–June 2025) tested exactly that. 𝗦𝘁𝘂𝗱𝘆 𝗮𝘁 𝗮 𝗚𝗹𝗮𝗻𝗰𝗲: 🧑💻 Participants: 16 experienced OSS developers (5+ years on their projects) 🗂️ Tasks: 246 real GitHub issues from large, mature repos 🛠️ Tools: Cursor Pro, Claude 3.5/3.7 Sonnet 🎲 Conditions: Randomized to AI-allowed vs. AI-disallowed 𝗥𝗲𝘀𝘂𝗹𝘁𝘀: 📉 Developers forecasted AI would speed up work by 24% 🧠 Post-task, they still believed it helped by 20% 🤯 Reality check: 𝗧𝗮𝘀𝗸𝘀 𝘁𝗼𝗼𝗸 𝟭𝟵% 𝗹𝗼𝗻𝗴𝗲𝗿 𝘄𝗶𝘁𝗵 𝗔𝗜 Even expert economists & ML researchers predicted a ~39% speedup. Instead: 𝗔𝗜 𝘀𝗹𝗼𝘄𝗲𝗱 𝘁𝗵𝗲𝗺 𝗱𝗼𝘄𝗻. 𝗪𝗵𝘆? With AI, devs: 🔍 Spent 𝗹𝗲𝘀𝘀 time 𝗰𝗼𝗱𝗶𝗻𝗴/searching ⏳ Spent 𝗺𝗼𝗿𝗲 time 𝗽𝗿𝗼𝗺𝗽𝘁𝗶𝗻𝗴, 𝘄𝗮𝗶𝘁𝗶𝗻𝗴, and 𝗿𝗲𝘃𝗶𝗲𝘄𝗶𝗻𝗴 AI outputs 💤 Faced more 𝗶𝗱𝗹𝗲 𝘁𝗶𝗺𝗲 and 𝗺𝗲𝗻𝘁𝗮𝗹 𝘀𝘄𝗶𝘁𝗰𝗵𝗶𝗻𝗴 𝗥𝗼𝗼𝘁 𝗖𝗮𝘂𝘀𝗲𝘀: 🙃 𝗢𝘃𝗲𝗿-𝗼𝗽𝘁𝗶𝗺𝗶𝘀𝗺 about AI's value ❌ 𝗟𝗼𝘄 𝗮𝗰𝗰𝗲𝗽𝘁𝗮𝗻𝗰𝗲 rate of AI suggestions (~44%) 🧱 Large, 𝗰𝗼𝗺𝗽𝗹𝗲𝘅 codebases too tricky for current AI 🧠 AI couldn't match developers 𝘂𝗻𝘄𝗿𝗶𝘁𝘁𝗲𝗻 understanding of the codebase 𝗜𝗺𝗽𝗼𝗿𝘁𝗮𝗻𝘁 𝗖𝗮𝘃𝗲𝗮𝘁𝘀: This doesn’t mean AI isn’t helpful, just that: 🧓 For very experienced devs on familiar repos, current tools may fall short 🆕 But for new projects, junior devs, or greenfield code, the story could be different 𝗟𝗼𝗼𝗸𝗶𝗻𝗴 𝗔𝗵𝗲𝗮𝗱: ✍️ Better prompting, lower latency, and domain-specific tuning might flip the results 🤖 Claude 3.7 already shows promise for partial task automation 𝗧𝗵𝗶𝘀 𝘀𝘁𝘂𝗱𝘆 𝘀𝘁𝗮𝗻𝗱𝘀 𝗼𝘂𝘁 𝗯𝘆 𝗯𝗲𝗰𝗮𝘂𝘀𝗲: 🌍 Using real-world tasks (not synthetic) 🧑🔬 Engaging expert developers ⏱️ Measuring fixed, real productivity (not just output volume) 🔗 Read the full study: Link in the comments 🤔 Have you noticed AI helping or hurting your coding workflow? #AI #SoftwareDevelopment #Productivity #MachineLearning