<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Berkay Turancı on Medium]]></title>
        <description><![CDATA[Stories by Berkay Turancı on Medium]]></description>
        <link>https://medium.com/@berkayturanci?source=rss-795ac1475ad9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ia5U4bmZgyaTFvlwug_Umg.jpeg</url>
            <title>Stories by Berkay Turancı on Medium</title>
            <link>https://medium.com/@berkayturanci?source=rss-795ac1475ad9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 10:07:41 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@berkayturanci/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Why I built a code review jury — and what I got wrong along the way]]></title>
            <link>https://medium.com/@berkayturanci/why-i-built-a-code-review-jury-and-what-i-got-wrong-along-the-way-ec09f641f6a1?source=rss-795ac1475ad9------2</link>
            <guid isPermaLink="false">https://medium.com/p/ec09f641f6a1</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Berkay Turancı]]></dc:creator>
            <pubDate>Fri, 03 Jul 2026 00:26:42 GMT</pubDate>
            <atom:updated>2026-07-03T00:26:42.181Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong>ai-jury</strong> — <a href="https://berkayturanci.github.io/ai-jury">berkayturanci.github.io/ai-jury</a> · <a href="https://github.com/berkayturanci/ai-jury">github.com/berkayturanci/ai-jury</a></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6B4DqO7P7ZGG_M0BA-zl1Q.png" /></figure><p>I’ve been using AI coding assistants for code review for a while now. They’re genuinely good — they catch things I miss, they’re fast, and they don’t get tired. But at some point I noticed a pattern that bothered me.</p><p>The same reviewer, reviewing the same diff, would catch different things on different days. And when I’d occasionally run two different AI tools over the same PR — not systematically, just out of curiosity — they’d disagree. Claude would flag something Codex had sailed past. Codex would push back on something Claude had approved. Neither of them was always right.</p><p>That’s when it clicked: the variation wasn’t noise. It was signal. Different models, trained differently, have different blind spots. And if the blind spots don’t overlap, running them against each other might surface more than any one of them alone.</p><p>I started calling it a jury, mostly as a mental model. What if instead of asking one AI for its opinion, you convened a panel?</p><h3>The first prototype was embarrassingly simple</h3><p>The initial version was basically a shell script. Run claude --diff, run codex --diff, concatenate the outputs, pipe to another Claude invocation that synthesized a summary.</p><p>It worked. Sort of. The synthesis model would occasionally surface disagreements I’d missed. But the output was freeform markdown — hard to deduplicate, impossible to gate in CI, useless for inline GitHub comments.</p><p>That became issue #1 in the project. Not “build the pipeline” — the pipeline already existed in rough form. The first real problem was <em>structured output</em>. If a finding can’t be parsed, it can’t be counted, sorted, deduplicated, or acted on. Every downstream feature (severity-gated CI exit, inline PR comments, consensus grouping) depended on each reviewer emitting something machine-readable.</p><p>That was the keystone. Once findings had a schema — severity, file, line, claim, evidence, suggested_fix, confidence, reviewer — the rest of the pipeline could be built properly.</p><h3>The constraint I set early that shaped everything else</h3><p>I wanted this to be something I could actually run in CI without worrying. That meant two things: it had to be secure, and it had to have no surprises.</p><p>Reviewers process attacker-controlled content. A diff is untrusted input. If a malicious diff could make the reviewing agent write files or run shell commands, that’s a problem. So from the start, every agent runs sandboxed and read-only by default — Claude with a write-tool denylist, Codex with -s read-only, Antigravity with --sandbox. The orchestrator owns what gets sent; the agents only read their prompt and print findings.</p><p>The other constraint was simpler but felt important: zero runtime dependencies. Standard library only. I wanted the tool to be something you could pipx install on any machine with Python 3.11 and have it just work — no dependency resolution, no supply chain to worry about, no version conflicts. Everything runs on subprocess, urllib, concurrent.futures, tomllib. Local model communication is plain HTTP over urllib. No requests.</p><p>These weren’t decisions I agonized over. They felt obvious for the use case.</p><h3>The problem I didn’t see until later</h3><p>The first real version of the pipeline ran three cloud CLIs: claude, codex, agy. Three different vendors, parallel review, debate round, chair synthesis.</p><p>And then I ran the benchmark.</p><p>I seeded a small set of labeled fixture diffs — a logic bug, a subtle boolean-guard issue, missing error handling, a false-positive trap, a docs-only change. I ran each model solo, then ran the full panel.</p><p>Solo: best models (Claude, Qwen) caught <strong>67%</strong> of seeded bugs. Codex and Antigravity: <strong>33%</strong>.</p><p>The full four-vendor panel: <strong>100%.</strong></p><blockquote><em>Small benchmark, N=5 fixture diffs — directional, not a universal claim. But it’s reproducible, and the effect held across every configuration I tried.</em></blockquote><p>That felt good. But then I looked at the panel configuration more carefully.</p><p>I had three proprietary, paid cloud CLIs. Every run cost real money. Running the benchmark across all fixtures, with all vendors, added up. More importantly: the research that the project’s own feasibility doc cited — Smit et al. at ICML 2024, Cohere’s PoLL paper — was clear that the load-bearing advantage is <em>model diversity</em>, not number of rounds, not model size. And I’d capped my achievable diversity at “three companies that have released a coding CLI.”</p><p>There was also a practical problem. If you want to contribute to the project and run the tests against real agents, you need three separate CLIs installed and authenticated. That’s a real onboarding wall. A first-time user can’t just pipx install ai-jury, run jury --pr 123, and see what the fuss is about. They need accounts, CLIs, credits.</p><p>Issue #43 was titled <em>“Add open-weight / local-model adapter to widen heterogeneity and cut cost.”</em> In the original roadmap, I’d put it in v0.6 — the “wait for real demand” bucket. But looking at the sequencing, that was wrong. The local model adapter wasn’t a nice-to-have feature. It was the thing that made the jury’s core thesis achievable without a credit card.</p><h3>Pulling it forward</h3><p>The implementation was less complicated than I expected. Any OpenAI-compatible server works — Ollama, llama.cpp, vLLM, LM Studio. Point at the endpoint, set a model, done. The local panelist participates in every round identically to the cloud CLIs.</p><pre>[[agent]]<br>name = &quot;qwen&quot;<br>vendor = &quot;local&quot;<br>model = &quot;qwen2.5-coder:7b&quot;<br>endpoint = &quot;http://localhost:11434/v1&quot;</pre><p>I was honest about the trade-off in the docs: a small local model is a weaker reviewer than a frontier CLI. Its value isn’t parity — it’s diversity, and zero cost. You pull qwen2.5-coder:7b with Ollama once, and that&#39;s a permanent fourth panelist that costs nothing per run.</p><p>The benchmark note for the local adapter says what it says: diversity contribution is real, but the precise numbers are within noise at N=5. I’m not claiming a small Qwen model catches bugs that Claude misses. I’m claiming it makes the panel more heterogeneous, and the research says that’s the load-bearing variable.</p><h3>The thing I didn’t plan: theater mode</h3><p>Somewhere around v0.5, I added a --live flag that streams each step as it happens — review, debate, verification, decision. That was practical. You could watch the run happen instead of waiting for the final report.</p><p>Then someone suggested making it more visual. The agents were already named. They had vendor colors. Why not render them as characters in a room?</p><p>--theater renders an animated deliberation scene in your terminal while the run is live. --theater-style pixel gives you a pixel-art room — four agents sitting around a table, taking turns, reaching a decision. It reads from the same event stream as the report, so it&#39;s not fake; it mirrors the actual run.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Hmgq0IRSemeiDI6jUuI3lg.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/995/1*5wBFKvtousp9k7TAS5t_nA.gif" /></figure><p>I didn’t expect to spend time on this. But it turned out to be the feature that made people actually want to run the tool. There’s something about watching four AI agents argue about your diff that makes the jury metaphor real.</p><h3>What the project actually is now</h3><p>ai-jury is a small, stdlib-only Python CLI that runs native coding-agent CLIs as an adversarial review panel. They review the same diff in parallel, debate each other’s findings, a chair agent verifies and synthesizes one verdict — APPROVE / COMMENT / REQUEST CHANGES. You can also run it in panel-vote mode, where the verdict is a majority vote rather than a single chair’s synthesis.</p><p>It handles PR review (--pr), diff review (--diff-file), issue review (--issue). Output is markdown, JSON, or SARIF for GitHub code scanning upload. It runs incrementally, handles large diffs via chunking, and can post findings back to GitHub as comments.</p><p>The install is one line:</p><pre>pipx install ai-jury<br>jury init    # detects installed CLIs and local models, writes jury.toml<br>jury --pr 123</pre><p>If you don’t have any cloud CLIs, jury init --list-models shows what&#39;s running in Ollama. You can run a real (non-mock) jury with just a local model.</p><h3>What I’d do differently</h3><p>The structured output schema should have been designed earlier, before I had any real pipeline. I built the schema to fit the existing output format, which meant some early architectural decisions were harder to change than they should have been.</p><p>I also deferred the benchmark too long. “Wait for real demand” was a defensible product call, but the benchmark is the most shareable artifact — the thing that earns attention and validates the thesis. I should have built it earlier and used it to drive the sequencing.</p><p>The roadmap has an “open question” section that flags both of these explicitly. I put it there so the trade-off was visible rather than accidental. If you’re picking up the project or building something similar, those are the two things I’d pull to the front of the queue.</p><p>The project is at <a href="https://berkayturanci.github.io/ai-jury"><strong>berkayturanci.github.io/ai-jury</strong></a> — docs, a live demo, and the architecture overview are all there. Source and issues at <a href="https://github.com/berkayturanci/ai-jury">github.com/berkayturanci/ai-jury</a>. MIT license, active development. If you try it and hit something unexpected, open an issue.</p><p><em>The jury is still out on a lot of things. That’s fine. The goal was to make the question empirically answerable.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ec09f641f6a1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Extend Agile]]></title>
            <link>https://medium.com/mirsadtech/extend-agile-163efc9f4719?source=rss-795ac1475ad9------2</link>
            <guid isPermaLink="false">https://medium.com/p/163efc9f4719</guid>
            <category><![CDATA[development-process]]></category>
            <category><![CDATA[process-improvement]]></category>
            <category><![CDATA[teamwork]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Berkay Turancı]]></dc:creator>
            <pubDate>Mon, 01 Nov 2021 10:26:28 GMT</pubDate>
            <atom:updated>2021-11-01T10:26:28.806Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Extended Agile Software Development — Part 1</strong></h3><p>Welcome to our first blog post. Please feel free to drop your comments below for asking questions or add knowledge to this guide.</p><p>Extended agile methodology, according to our definition is, uses agile methodologies combined with a strict set of rules for the processes of such methodologies to <em>achieve better productivity and efficiency</em>. Undoubtedly, there are many agile methodology guidelines that can conflict with ours. However, this guideline has taken shape with eight years of experience in <strong>real-life scenarios</strong> and continues to develop by overcoming bottlenecks during the processes and adding new rules to overcome newer problems.</p><p>To fully comprehend this guideline, some basic knowledge about, including but not limited to, GitFlow, Pull Requests, Code review, Unit tests, CI/CD are required. These topics will be explained briefly before mentioning them. You can learn more about those in detail by reading our upcoming posts or researching on the Internet.</p><p>This is the first part to explain how to reach ultimate Agile processes with integrated rules and points. We will try to cover different perspectives of Agile team members in upcoming writings; Developers, analysts, testers, product owner.</p><p>Firstly, the main focus will be on general aspects and how Agile methodology works, briefly. In our next blog, we will focus on the developer’s point of view during the processes. Let’s start with some keynotes;</p><h3><strong>Team: Agile team members have different roles who are responsible for successful sprint completion.</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PMdUk-XS2-Irw1UR_5vZkQ.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@lazizli">Lala Azili</a> from <a href="https://unsplash.com/photos/tfNyTfJpKvc">Unsplash</a></figcaption></figure><p>Like in a sports team every position can require different skill sets or job titles in Agile. We should not only think of developers as an Agile team. Agile team should be considered as a team that can live and develop an app by itself.</p><ul><li><strong>Developers</strong> are responsible for writing the code for the application. We can combine all sorts of developers to this section such as Backend developers, Full-stack developers, Front-end developers, iOS or Android developers, etc. We also consider other technical roles in this title such as Application Architectures, DevOps, DB Admins, etc.</li><li><strong>Testers</strong> are responsible for ensuring the written code fulfills the requirements of the application and detecting bugs. In some teams, testers are also responsible for writing test codes such as Test Automation, UI Tests, Stress Tests, etc. to increase the quality of the application. Testers should also report missing parts on the user experience side. In addition, they should monitor the errors received by the users using the live application through analytical tools and evaluate errors according to their priority.</li><li><strong>Analysts</strong> are responsible for writing the analysis report which is used by the developer to code the requirements (features) and by the tester to create test cases and verify that the written codes are cover the analysis report. Analysts are also can be considered <strong>Scrum Masters </strong>for the team. Analysts and Analysis documentation are vital to reflect customer needs with technical understanding. The analysis report is different than software requirement documentation and defines application flows by covering all conditional cases without missing any points about the feature or new requirement.</li><li><strong>UX/UI Designers</strong> are responsible for creating visual interfaces or perspectives to the applications and flows to make responsive, user-friendly, and good-looking apps. Having a UX/UI designer in the scrum team is not mandatory but it is recommended.</li><li><strong>Scrum Master</strong> is a person who orchestrates the sprint to reach success. This person can either always be the same or can be changed any time by choice. This person can also be a developer but is usually selected among testers or analysts. This role has vital responsibilities such as supporting each team member and clearing obstacles in the path during the sprint days. Meetings are also managed and controlled by the scrum master.</li><li><strong>PO or Product Owner</strong> is usually one person who communicates with app users or customers to obtain their needs or wishes. They are also responsible to track new technologies to draw a roadmap to the application aka the product. After taking the needs from the customers, PO should transmit those needs to the Analysts for generated related analysis reports which can be used afterward for implementation. Product Owners usually attend the Sprint planning and Refinement meetings only and they are not the core unit on the Scrum Team.</li></ul><h3><strong>Sprint: Duration of a time where taken tasks should be started and completed by the scrum team members.</strong></h3><p>Sprint represents a fixed repeated timeline for the scrum team. In this period, each job should be started and ends before the sprint ends. Tasks can be development, testing, documentation, or other things like meetings, job interviews for the technical leaders, demonstration to the customers, etc. It is important to reflect all these tasks to the sprint plan to avoid misplanning. Usually, the duration of the sprint should be between 2 weeks to a month. To complete the sprint successfully, the commitments should be fulfilled by the team during the agreed duration of the sprint. All team members are responsible for having a successful sprint. For the next sections when we talk about sprint duration it is 2 weeks.</p><h3><strong>Meetings: “Hearth Rate Monitors” of the sprint.</strong></h3><p>There are fixed meetings in Scrum methodology. Those meetings are required to guide the team and organize the Sprint status.</p><ul><li><strong>Daily meetings — Standup meetings </strong>are the meetings that are executed each day to check the status of the sprint plan. In this meeting, each team member explains what has been done on the previous day, what will be made today, and concerns or problems if there are any. It is recommended to have this meeting in the early morning like 09:05 before starting the tasks. This shouldn’t be a long meeting and every person should not speak for more than 2–3 minutes. Scrum masters lead this meeting by permitting people to speak in alphabetical order according to their name. In a recommended way, all scrum team members should attend and talk about their tasks in this meeting. At the end of the meeting, Burndown Chart can be used to check the status of the sprint.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q8Now2v3loTeoKsTVA1qFg.png" /></figure><ul><li><strong>Sprint refinement meeting </strong>is a meeting that occurs only one time in the middle of the sprint. Let’s say if our Sprint starts on Monday after the planning meeting, this refinement meeting occurs next Monday. In a refinement meeting, we adjust the ongoing sprint plan because the priority of tasks may change over time due to the customers’ needs. If no priority changes occur, then adjustment may not be required. This meeting is also important to pre-adjust future sprint tasks. If some information is missing about the task that will be taken in the upcoming sprint, there can be small talks about clearing the missing information with external participants. This refinement meeting can be done with a small group of persons including the product owner, analysts, technical leads, and some testers.</li><li><strong>The sprint planning meeting </strong>is a meeting that members plan the next sprint, which occurs on the first day of the sprint. These planning meetings are crucial for team commitment. If the capability or velocity of the team overflows by the new tasks, then commitments may not be completed or overtimes are required. If lots of free time is given to the team after planning, then customer requests may not be fulfilled at a time. So, the best way is not to overflow or underflow the total task weight. The recommended way to weigh tasks is using Fibonacci story points. By considering one day as 5.5 points, for a person sprint is 55 points (for a two-week sprint), members estimate the tasks by considering all the task’s aspects such as reviewing, testing, coding for the development. This is a challenge that requires attention because estimating a new task requires previous experiences and skills that need to be compared against previous tasks. Also, the estimation can vary by the task owner’s experience, domain knowledge, and project know-how. For example, junior team members may require more time than senior team members to complete this challenge. Our recommendation here is to assign each sub-task to team members before giving the story point. Moreover that, breaking the tasks into sub-elements can give the advantage of seeing the sub-modules or sub-tasks and have advantages for evaluating the story point. The weighting phase may vary depending on the dynamics of the teams. The key point here is to score the task independently of the individual, but not to ignore the team’s talents.</li><li><strong>Sprint ending meeting — Sprint evaluation/review </strong>is a meeting that is done just before the planning meeting for the next sprint to close the current sprint. By comparing the work logs and estimations, the overall success of the estimates can be calculated. This is very important because in each sprint cycle you want to increase your estimation precision to give more accurate story points to eliminate overflow or underflow situations.</li><li><strong>A retrospective </strong>meeting is a meeting that is used to evaluate the previous sprint process. It can be used to speak about process bottlenecks or the problems that the team had during the sprint. This is a free speech zone where every team member can express themselves and his feelings openly. If there were problems in the sprint, they should be addressed in this meeting. Each meeting should be recorded or documented by asking what did the team do well and in what way they would have done better. Getting answers from everyone is important. This will give the advantage to see how the process improves over sprints by answering the following questions; Are we making the same mistakes? Did we overcome the issues that we had previously? Do our team members get happier over the period? So to find those answers, we ask the following questions in each retrospective meeting;</li><li>What did we make good in this sprint?</li><li>What processes should we improve?</li><li>Action items</li><li>Happiness / Stress points over 10 and how they are feeling about the sprint.</li></ul><h3><strong>Kanban Board: Columns to track jobs status.</strong></h3><p>Kanban board is used to track a task’s status in a table view. There are many tools to manage your Kanban board like Jira, GitLab, Trello, Asana, etc. If you do not want to use the software you can use stick notes and pen too :). However, to apply rules to your processes, you should stick to the software that allows defining those rules. We recommend having 5 columns as follows; To Do, In Progress (aka Work in Progress or WIP), In Review, Testing, Done. Each column shows the state of the task.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8wruUmB0KUNq8jpINiqP1Q.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@irfansimsar">İrfan Simsar</a> from <a href="https://unsplash.com/photos/wxWulfjN-G0">Unsplash</a></figcaption></figure><ul><li><strong>To Do </strong>column is used to show a task that is not yet started. Hence, the assignee person can be changed since work is not yet started.</li><li><strong>In Progress</strong> column shows that the task is currently active. The assignee is currently working on that task and the task should not be transferred to another person. Also, there can be some changes for the development phase since it is not yet ready to review. We recommend opening a pull request for the branch related to the coding task with the title format: [DRAFT] or [WIP] &lt;Task Name&gt;. Development should be done by looking at the analysis report that is generated for the task.</li><li><strong>In Review</strong>, a column is used to describe the task is done from the perspective of the assignee and ready to be reviewed by other team members. However, this is not testing. If the task is a coding task, reviewers should control the general coding standards, check if the code is clear to understand, if the assignee stuck to the agreed software architecture, and wrote sufficient unit tests, etc. We will also add a blog post about the code review checklist since it is very detailed on its own. If the task is an analysis task, the report should be reviewed to see if there are any missing cases and clear to understand. “Review is done” state can only be achieved when all technical reviewers of the pull request have approved.</li><li><strong>Testing</strong> column is used to describe a task that is ready for testing and should be assigned to one of the testers in the team once it is moved to this column. The tester should check if all technical members approved the pull request before testing the task. If all is approved then it is ready to test, otherwise, it can be assigned to the developer again. In this section, the tester should control the changes with test cases that are generated from the analysis report. Test engineers should approve the task not only by looking if it’s bug-free or not but also by checking if code changes satisfy the analysis report. This can be considered as verification &amp; validation. If all is okay from the tester’s perspective, the task assignee is changed to the analyst, a comment should be added to the task detail about the testing process that took place specific to this task, and then approval is given to the pull request by the tester (We will tell why testers are also approve pull requests in our upcoming writings). This means that the task is ready to merge by the analyst. If the analyst knows that this task will be released in the upcoming release package, she/he also approves the pull request and clicks on the merge button. Since the task is merged the related package information should be added to the task by the analyst and moved to the Done column.</li><li><strong>Done</strong> column is used to understand the task is done and should not be worked on it anymore in this sprint. It may be merged to the package by the analyst if this coding task will be available in the next release. For the soft tasks, the analysis report should be attached and finalized.</li></ul><p>That’s it for Part 1 of Extended Agile Software Development. Some parts may not be fully comprehended but with the following parts, we will try to get rid of this fog and show the reasons underneath with details.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=163efc9f4719" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mirsadtech/extend-agile-163efc9f4719">Extend Agile</a> was originally published in <a href="https://medium.com/mirsadtech">MirsadTech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>