Chris Copeland

💡 AI doesn’t just change how code is written – it changes expectations and outcomes. In the final section of Jellyfish’s AI Adoption Guide, we explore how expectations for engineering leaders are evolving as AI becomes embedded across the SDLC. Because the organizations pulling ahead are treating AI as a transformation, not a tooling upgrade. Inside, you’ll explore: - Why AI adoption is quickly becoming a leadership mandate, not an option - How to balance ambitious goals with realistic expectations - What cultural investments are required to sustain long-term gains - How data can be used to align executives and engineering teams The teams that win in the AI era won’t just have better tools – they’ll have leaders who know how to guide change. Download today: https://lnkd.in/dut_6WpQ

19

I see a lot of confusion between Continuous Delivery and Continuous Deployment. Continuous Delivery means that your software is shippable at any time. That *could* mean that deployments are happening automatically on every green build, multiple times a day. Or it *could* mean that a releasable product is packaged ready-to-go on every green build, and the business decides when. Or it *could* mean that the software's deployed into a user testing or staging environment for further evaluation on every green build. What happens after that green CI build will depend on the situation, and automatic deployment's by no means a given. Continuous Delivery is a prerequisite for Continuous Deployment, but it's not the same thing as Continuous Deployment.

78

5 Comments

Your feature spec gets written before you finish your espresso. Pull requests land before lunch and writing tests hijacks your morning. You spelunk through ancient wiki pages to find just enough context to not break production. Fewer devs. More code. Every missing detail stings. In a world where AI shaves weeks into hours, code reviews and tests are the new bottleneck. The game just shifted again Google Veo 3 dropped, and it’s mind-blowing. If AI can generate Hollywood scenes, why are we still stuck in manual mode? Something’s changing fast

11

It is impossible to call yourself an experienced infrastructure/distributed systems engineer if you have consistently switched jobs every two years. You become a rockstar engineer by building complex infrastructure, operating them at scale, migrating users, fixing issues and rolling out v2/v3 of the system. You learn a lot going through this cycle and learn important life lessons. It typically requires persistence and continuous grind for years to build reliable and scalable systems. My advice is to commit and persist for four years or more at a place to become a solid distributed systems engineer. Sounds old school but this is how it works. AI is not going to speed this cycle anytime soon for building deep distributed systems.

303

22 Comments

🔒How to Build an Agent with Auth and Payments Fullstack agent application! Not only can LangGraph + LangGraph Platform help you build agents, it can also help you deploy them and supports custom auth and middleware for usage tracking Video: https://lnkd.in/ghu5cGKa

241

3 Comments

Terraform's original sin is the state file. We built modern infrastructure on fragile JSON blobs in S3. Every project its own island, no global view, no history, just grep and jq when you need answers. Here's the reality: Terraform sold us "infrastructure as code," but stopped short of making it infrastructure as data. What we got was infrastructure as scattered text files with the relational depth of a Post-it note. State should be a living data source. Queryable. Auditable. Real-time. Exposed through APIs your tooling can actually use. #terraform

501

106 Comments

"APIs are the connective tissue that allow an organization to thrive." Nearly every company I speak with is navigating the same challenge: modernizing their API landscape while preparing for AI-driven systems. The biggest brands want clear guidance on how to govern, scale, and future-proof their APIs as AI becomes more central to how software is built and operated. This conversation with Matthew Gray, Head of Channel Sales at Postman, does a great job exploring what that journey looks like in practice and why APIs sit at the center of it. Full discussion: https://lnkd.in/g8qUX9dt

126

5 Comments

Scaling Platform Engineering: Abby Bangser’s Kubecon keynote We build platforms to reduce scope & complexity for those who build on top. Develop platforms for what’s unique to the business and common to the teams. Give delivery teams focus, without taking away ownership. This isn’t easy. Make it easy for everyone to spin up clusters (via self-service or a template) and you’ve given everyone a puppy. Who is cleaning up after its CVEs? Now the platform team is responsible for a bevy of puppies running around the org, and they don’t get any of the snuggles. Abby’s principles of platforms: 1. API-first self-service: codify your expectations. 2. Full lifecycle business compliance: keep being relevant after startup. 3. Fleet management by capability providers: treat this as a managed service, with upgrades. That “capability providers” part–when this is a centralized platform team (me: always underfunded), they can’t keep up with requests, and then you get shadow IT. Instead, let’s make our platform like the iPhone and give it an App Store, with a self-service _capability creation_ API. Like when kubernetes added custom resources! Let platform innovation be nurtured across the organization. Great keynote Abby Bangser !

154

13 Comments

It's true - Rails is overpowered in the world of AI generated code. And anywhere ruby falls short you can delegate to microservices in any language. Riveter runs on rails and processes up to tens of millions of agent runs a week.

271

72 Comments

Six months ago, Spotnana engineering committed fully to Claude Code and Cursor. Adoption happened quickly and naturally. What surprised us most was a feature released last July in that many developers still haven't discovered: custom sub-agents. When you use ClaudeCode in its default form, you're working with a capable generalist. Custom sub-agents let you create specialists instead. You define them by placing a markdown file in the .claude/agents/ directory with simple YAML frontmatter that sets the agent's name, persona, and allowed tools. Claude then automatically delegates tasks to the appropriate specialist based on context and no manual prompting required. Each sub-agent runs in its own isolated context window, so your main conversation stays clean. The agents are also shareable across projects, which lets institutional knowledge build over time. The biggest challenge we faced was getting routing reliable. When agent descriptions overlap even slightly, Claude struggles to choose the right one. We've learned to make each persona description extremely precise and distinct. Another lesson came the hard way: sub-agents inherit your permission settings by default. I once gave a research-focused agent write access, and it began refactoring code while trying to investigate a bug. One improvement I would love to see is a clear post-session audit log that shows which agent handled which actions and when. Right now, tracing responsibility requires digging through long transcripts, which slows down debugging and makes accountability harder. If you're already using Claude Code (or Cursor with Claude) and haven't tried the /agents feature yet, you're missing out on significant capability. What sub-agents has your team built, and how have they changed your workflow? #ClaudeCode #AICoding #AgenticAI #CursorAI #DeveloperTools

58

3 Comments

The worst thing to do when building a scalable system is to build it at scale, yet this is what happens most of the time. I was recently reminded that 10 years ago, I told Jamie Dobson that I didn't build systems at scale but rather systems that could scale when needed. It wasn't a big deal for me then, but the fact that it still resonates 10 years later must be a sign that the difference isn't always obvious to everyone. Something about BIG attracts us. BIG systems usually come with interesting engineering challenges, and we (or at least most of us) love a good engineering challenge. Unfortunately, good engineering challenges also destroy all ability to meet a deadline. They're like black holes. Once an engineer is caught in the gravitational pull of an engineering challenge, they're lost. When we're dealing with deadlines, small and simple are key. Keeping something elegantly simple is a great engineering feat. It's actually far more difficult than some of the "The Incredible Machine" constructs that I see people call software. Don't be fooled by the meaning of deadlines. They're not always time-bound. If you work for a startup, your deadline is most likely financial. You want to prove your product-market fit before the money runs out. In practical terms, this generally means that we should stop building microservices. Instead, build one simple, monolithic system that does exactly what you need it to do. You'll want to prove that you can scale the system to one user first. In my time as a software architect at a consultancy firm, I've seen many beautiful large-scale technical solutions, but the business concept didn't scale to its first customer—a great way to waste money. Monoliths aren't necessarily bad. When appropriately designed, you can remove components from the monolith, deploy them separately, and even scale them dynamically. You'll want to postpone this for as long as you can. After all, the more deployment units you have, the more complex the environment becomes. In 17 years of applying CQRS and Event Sourcing to projects, I've learned that explicit messaging (Commands, Events, and Queries) greatly enables the modularity required to scale monoliths to microservices. I've not seen other approaches (yet) bring capabilities that come even close. The diagram below is a mildly modified version of the diagram I use in most presentations. My general recommendation is the same. The ideal place for software is as far up as you can get it (as modular/scalable as possible) and as far left (monolithic) as you can get away with.

68

2 Comments

I’ve been doing podcast interviews lately and talking about what drove me to create Dragonfly. It’s been fun to reflect on it now that Oded Poncz and I are three years in. A few highlights: * I experienced the pain and complexity of scaling Redis firsthand as an engineer at Ubimo (ad tech startup). I managed a large Redis cluster that was mission critical and it was very unreliable at peak loads and the only way to overcome this was to throw more money at the problem (still could not do snapshotting though) * I worked at AWS ElastiCache, one of the largest managed Redis services in the world. There we still faced the same issues that are inherent with pushing a technology past the scaling limits it was designed for. These experiences convinced me that engineering teams need a more performance, efficient, and reliable in-memory data store that is designed for modern cloud workloads and scale. That is why I built #dragonfly. 

60

5 Comments

Starting off the year strong.... Amazon MQ just took a big step forward for teams standardizing on RabbitMQ by delivering support for HTTP-based RabbitMQ message brokers, making it easier to integrate messaging into modern, cloud-native applications without managing any underlying infrastructure. This means development teams can connect producers and consumers over HTTP, simplify network configurations, and better align messaging with existing API-driven architectures. https://lnkd.in/gjf3-fFv #RabbitMQ #MessageBrokers #Messaging #AmazonMQ #AWS

64

I love this take on the “10x engineer” phenomenon. Ubuntu (the African concept, not the OS) strikes again. “I am because you are”… “Individual engineers don’t own software; engineering teams own software. It doesn’t matter how fast an individual engineer can write software. What matters is how fast the team can collectively write, test, review, ship, maintain, refactor, extend, architect, and revise the software that they own.” https://lnkd.in/g725SPDb

40