How I shipped 39 PRs to prod as a non-developer

How I shipped 39 PRs to prod as a non-developer

What a product manager learned shipping pull requests to a client's production codebase

Josh Korr

November 20, 2026

In the spring and summer of 2026, I shipped 39 pull requests to a client project’s production codebase using Claude Code and my team’s agentic development process.

These were real, production-ready contributions. Not AI slop. And I’m not a developer.

I didn’t suddenly become an engineer, and Claude didn’t magically do everything for me. What made this possible was a combination of established engineering practices, a thoughtful agentic development process, and a team of developers who knew when to let me run with something (and when to step in).

Here’s what I built, how it worked, where it broke down, and what I learned about the role non-developers can play in agentic software development.

First, some context

The product: A website-building platform for artists.

The project: Redesigning and rebuilding a 20-year-old product from the ground up to enable innovation and growth, and better meet artists’ needs.

The 8th Light team:

  • Lead developers: Kelsey Roy and Kevin Kotowski
  • Design: Agustin Sanchez
  • Product: Me, Josh Korr

A little about me: I’m not a developer, but I have 17 years of technical product experience, an idiosyncratic specialty in product definition, and a decent design eye.

On this project, I was the strategic technical product manager, facilitating cross-functional discovery and solutioning, writing specs, doing QA, and, as it turned out, building. At 8th Light, I split my time between client projects like this one and efforts to shape our broader strategy and enablement.

What I built (and how legit was it?)

https://assets.8thlight.com/images/insights/blog-work-kinds.png



Bug fixes:
A page title getting cut off in the editor, a button that stopped working after an image upload, and links that ignored the user’s chosen color.

Presentational updates: Copy changes, icon swaps, reordering form fields, modal redesigns, and styling updates to match the latest designs.

Small functional updates: These went a step beyond presentation, changing behavior and sometimes touching models and controllers as well as templates. I added text-alignment controls to the page editor, made a page-visibility icon functional (click to unhide a page), and built empty-state UI with temporary placeholder content for three page types. The largest of those was 900 lines.

Two bigger features: An MVP contact form and artwork detail page styling controls, which I’ll get into later.

 

https://assets.8thlight.com/images/insights/blog-pr-sizes.png

So, how legit was the work?

I was pleasantly surprised by how well it held up. Of my 39 PRs:

  • 22 (62%) were good as submitted (nothing beyond lint).
  • 17 (38%) got dev changes, ranging from a few lines to replacing most of Claude’s code.
https://assets.8thlight.com/images/insights/blog-quality-split.png

Kelsey and Kevin continually assessed whether my agentic work met the project’s quality bar. It did, so they let me keep going.

That doesn’t mean everything Claude produced was great. The changes developers made generally fell into two categories.

Not following established codebase conventions or architecture

Sometimes Claude produced working code that didn’t follow the patterns we’d already established. That’s risky. One-off implementations can introduce future bugs, make the codebase harder to maintain, and create bad examples for future agentic development to draw from.

A few examples:

  • Writing custom component CSS instead of using our established Tailwind/DaisyUI patterns.
  • Building a custom Turbo Stream detour for save notifications instead of using the codebase’s established client-side dispatch on turbo:submit-end.
  • Using a hacky pagination workaround that overwrote Pagy’s internal count via instance_variable_set, complete with a comment explaining why the trick was supposedly safe. Kevin replaced it with a straightforward implementation using an explicit @vault_count.

Functional bugs caught through developer QA and code review

Most of these showed up in failure paths or edge cases. An unconfigured form left an empty div on published sites. Some form text was invisible against dark backgrounds. My manual QA could have caught those issues, but I was mostly testing happy paths.

Other problems weren’t visible through QA at all. One hover overlay looked perfectly fine on screen but was hidden incorrectly in the underlying code. The developers caught those issues by reading the code. As a non-developer, I can’t meaningfully do that.

That’s an important distinction. I could validate whether something worked from a product and user-experience perspective, but I couldn’t independently assess whether the implementation was sound.

How I did it (without making a mess)

The obvious stuff: A strong foundation and some caution

At a high level, I could do legitimate agentic development because I was building on an already excellent foundation. And because we were careful about how far I pushed it.

Existing agentic development tooling: I owe much of this to Kelsey and Kevin, who were already at the vanguard of agentic development at 8th Light. They’d built and iterated on a robust process before we even considered plugging me into it.

Their Research-Plan-Implement process (RPI) is similar to the approach my colleague Alex described in his article.

Human code review: Throughout my agentic development experiment, project PRs still went through manual developer review. My work was no exception.

A mature design system: We had a robust Figma design system, additional reference designs, and many of those components already built into the application. That gave me a reliable way to communicate design intent and constraints to Claude.

Knowing my limits: We deliberately started small to see whether I could produce quality work, then gradually expanded the scope of what I took on. Our north stars were simple: Don’t pollute the codebase, and don’t disrupt developer progress. With great power comes great Claudesponsibility. 🕷️🤖

https://assets.8thlight.com/images/insights/firstPR.png

My very first agentic PR. Intentionally small — you gotta start somewhere!

The less obvious stuff: A feature case study

That foundation was necessary, but it wasn’t sufficient. As I got further into the work, I realized there were a few less obvious things that made agentic development viable for someone like me. Interestingly, some of these are just as important for developers using AI.

I’ll illustrate them through one of the larger features I worked on: artwork detail page styling controls. For an artist, showcasing individual artworks is central to their website. This feature gave artists more control over how those artwork detail pages looked.

https://assets.8thlight.com/images/insights/Artwork-Detail-Prototype.png

The prototype for artwork detail styling controls.

1. Collaborative solutioning happened before Research-Plan-Implement

The most important work for this feature happened before I ever started RPI. It was the same cross-functional discovery and solutioning that’s always been central to our product process. Call it human-before-the-loop.

https://assets.8thlight.com/images/insights/Collaborative-Solutioning-diagram.png

The product founder first raised the opportunity during one of our regular cross-functional working sessions, acting as both a power user and the voice of the customer.

We asked questions, explored ideas, and discussed what might work. Agustin, our designer, then created a Claude prototype that we reviewed internally and with the founder. After a few iterations and some scope decisions, I turned that collaborative work into a spec and fed it into RPI alongside the prototype.

There’s a bit of a myth out there, or at least an impression some AI gurus and frontier teams give, that agentic development begins when you open a Claude session and start ideating. Then a spec somehow emerges from [muffled hand-waving].

Maybe that works for solo projects. But it’s not how our cross-functional client work operates.

A good spec is the output of collaborative solutioning, not a substitute for it. AI tools are increasingly helping us accelerate that earlier work, but they haven’t replaced the human judgment, user insight, creativity, or collaboration that make it valuable.

2. I was opinionated about how to break up the work

Once we had a clear direction, I spent time deciding how to chunk and sequence the implementation.

I knew I wanted to handle the first part myself and hand off the rest to the developers. So I broke the feature into manageable pieces for individual RPI implementation passes, sequenced them to minimize dependencies, and reviewed the plan with Kelsey before finalizing it.

https://assets.8thlight.com/images/insights/Chunking-Sequencing-Accompanying-Image.png

My spec doc included opinionated chunking and sequencing.

This was more than project management housekeeping. It helped me take on work I could reasonably validate without creating unnecessary complexity or slowing down the developers.

3. I stayed actively involved in research and planning

Throughout my agentic deventure, I’ve been very engaged in rpi-research and rpi-plan, even when much of the output is too technical for me to fully understand. I’m constantly looking for errors, hallucinations, questionable assumptions, or anything that just doesn’t seem clear.

For example, here are a few things I actually said to Claude while researching and planning the artwork detail styling feature:

  • “I don’t know at all what you’re referring to.”
  • “This seems very clear and obvious in the prototype. What are you looking at that makes this a question in your mind?”
  • “I don’t know what you mean by Phase 1 and 2. Those don’t seem like helpful concepts.”
  • “Let’s discuss further to nail it down.”

One of my rather direct Claude interactions. I’m (usually) much more polite to my human colleagues.

https://assets.8thlight.com/images/insights/claudeinteraction.png

The point is that I wasn’t just accepting whatever Claude produced. Even without understanding every technical detail, I could challenge its interpretation of the requirements, identify gaps in its reasoning, and push for clarity. A lot of that comes down to product judgment, not coding ability.

4. I moved product QA into the implementation loop

Normally, I did manual product and design QA on other developers’ work after it had gone through code review, been merged, and deployed to staging. For my own agentic development, I effectively moved that QA into the implementation loop.

https://assets.8thlight.com/images/insights/QA-in-the-Loop.png

Claude’s first pass frequently had functional errors or, more commonly, presentation issues. Sometimes the second and third passes did, too. Rather than opening a PR and waiting for someone else to catch those issues, I’d test the implementation, give Claude feedback, and keep iterating until it met my QA standards.

https://assets.8thlight.com/images/insights/rpiimplementclaude.png

One of many presentation issues I surfaced after rpi-implement’s first pass.

By the time I opened a pull request, I’d already done much of the product QA that would normally happen later in the process. That didn’t eliminate the need for developer review, as the issues I described earlier make clear. But it meant the work was further along before it reached them.

https://assets.8thlight.com/images/insights/commitrecord.png

This commit record tells the tale of my iterations within rpi-implement.

What I learned

Smaller is better

The clearest pattern from my 39 PRs was that smaller updates were a much better fit for me.

Of the 26 PRs under 100 lines, 19 merged without substantive changes (73%). And the total time invested wasn’t meaningfully different from having developers implement those kinds of updates, aside from some of the knowledge gaps I’ll get into below.

https://assets.8thlight.com/images/insights/blog-size-clean.png

The bigger features were another story. They required enough developer involvement that we probably lost some of the benefit of working in parallel.

That said, the collaborative solutioning and clear RPI inputs I described earlier become even more important as features get larger. And product managers or designers are often well-positioned to own that work, even if developers ultimately handle the implementation.

My non-developer knowledge gaps were real

Looking back, some of my most frustrating moments came from surprisingly mundane gaps in my development knowledge.

Basic developer logistics

I confess I have been largely Git-ignorant; I don’t fully understand repos, branching, rebasing, general Git hygiene, etc. Separately, I had several QA rabbit holes that turned out to be stale JavaScript or Tailwind in my local environment. I spun some wheels around all of that: not a huge time-suck — maybe an hour across 39 PRs — but still frustrating and unnecessary.

Developers encounter the same AI problems, but know how to catch them

Some of the issues I mentioned earlier, like ignoring codebase conventions or established architectural patterns, happen when developers use agentic tools, too.

Kelsey, for example, has seen Claude write raw CSS instead of following the application’s Tailwind conventions, even though those conventions are explicitly documented in our RPI instructions. The difference is that she recognizes the problem and corrects it during implementation. I don’t have the knowledge to spot it, so it makes its way into the PR.

The Turbo gotcha

Some seemingly simple bugs and presentation updates turned out to be more complicated because of the application’s tech stack.

We were working with Rails and Hotwire, including Turbo Frames, Turbo Streams, and Stimulus controllers. A later analysis of my agentic work using Claude found that nontrivial developer feedback tended to cluster around the Turbo lifecycle: streams, frame loading, event timing, and DOM persistence across navigation.

In retrospect, some of those Turbo-heavy updates probably weren’t the right things for me to take on.

So, could any non-developer do this? (#YNDMMV)

Honestly, no. But not because it requires some kind of unicorn.

It takes a particular combination of skills and experience, most of which aren’t traditionally associated with writing code: strong product definition, technical mental models, a good design eye, QA habits, fluency in the current design state, and the judgment to know what not to take on.

Our product and design team at 8th Light each brings a different version of that skill set. And I think it makes us valuable force multipliers in the agentic development era.

But your non-devs’ mileage may vary. #YNDMMV

Is it actually a good idea?

There’s plenty of industry debate about whether non-developers should be doing agentic development.

I’m not going to try to settle that debate for everyone. I can only speak to our context at 8th Light: a boutique consultancy doing high-value, cross-functional client work with high expectations for quality.

My take? If the budget allows, and we can address some of the mundane friction I described above, having non-developers who can contribute to production software is an awesome option. I see a few particularly valuable opportunities.

Knocking out smaller work without pulling developers away from bigger problems

Developers almost always have more complex work to focus on. Letting a product manager or designer handle smaller updates can free up engineering capacity while still delivering meaningful product improvements.

Those improvements might seem minor individually, but they can add up.

Reducing the back-and-forth on presentation details

When developers are less presentation-minded, or when QA consistently surfaces styling issues, it can be more efficient for a design-minded non-developer to implement smaller UI updates directly.

There’s also a lot of potential here as AI-generated prototypes get closer to production-ready front-end code. Ideally, a prototype becomes a head start on implementation rather than something developers have to recreate.

Making small, forward-deployed teams more flexible

In forward-deployed engagements, small teams embed within an organization to solve ambiguous operational problems through rapid discovery, prototyping, and implementation. Having non-developers who can contribute directly to the build makes those teams more flexible. The same people helping define the problem can also help turn solutions into working software.

The bigger takeaway

I started this experiment wondering whether I could contribute production code without being a developer. 39 PRs later, the answer is yes, but with some pretty important qualifications.

I didn’t replace a developer. I worked within a system that experienced developers had built, benefited from their review, and relied on my own product and design skills to contribute in ways that made sense. And that’s what makes this interesting to me.

Agentic development isn’t just changing how developers write code. It’s creating opportunities for people with different expertise to contribute more directly to building software.

The trick is knowing where those contributions add value, where the limits are, and how to maintain the engineering rigor that makes it all work.

Josh Korr

Product Director

As Product Director, Josh brings more than 15 years of experience discovering and delivering keystone product and transformation outcomes in a range of industries. From unicorn startups to Fortune 500s, he empowers teams, aligns stakeholders, and catalyzes complex initiatives by turning fuzziness into shared clarity.