<?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 Matthew Eckstein on Medium]]></title>
        <description><![CDATA[Stories by Matthew Eckstein on Medium]]></description>
        <link>https://medium.com/@mattheweckstein?source=rss-70540cefffac------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ncCOrs46JEP1dZtJMt6Hnw.jpeg</url>
            <title>Stories by Matthew Eckstein on Medium</title>
            <link>https://medium.com/@mattheweckstein?source=rss-70540cefffac------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 08:41:33 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mattheweckstein/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[The Move to React Native]]></title>
            <link>https://medium.com/swlh/the-move-to-react-native-969391f0af97?source=rss-70540cefffac------2</link>
            <guid isPermaLink="false">https://medium.com/p/969391f0af97</guid>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <dc:creator><![CDATA[Matthew Eckstein]]></dc:creator>
            <pubDate>Fri, 17 Apr 2020 23:15:49 GMT</pubDate>
            <atom:updated>2020-05-03T01:02:47.513Z</atom:updated>
            <content:encoded><![CDATA[<p>About six months after joining ClassPass, I found myself managing all of the mobile engineers in the department. This wasn’t by design, I just happened to take over all of the engineering squads that contained mobile engineers. It was an opportunity to examine and improve mobile engineering at ClassPass. One of the biggest opportunities we identified was exploring just how widely we could use React Native in our mobile development.</p><p>React Native is a tool; it’s right for some jobs and not for others. And like any tool, it has real power when applied to the right job. It can speed up development in a number of ways. You can surge web engineers into mobile projects in a way you can’t when writing native code, because it’s JavaScript and based on React. Its hot reloading increases engineering velocity since you don’t have to wait for compilation to see your changes. But the biggest benefit is that you can build features once and launch them on both iOS and Android apps.</p><p>Like many startups, ClassPass had more work on our product roadmap than we would ever have time to do. It was clear that building features for our mobile apps with half the effort could be a huge win for the company. But when you already have two large mobile codebases and mobile engineers who have had little to no experience with React Native, a transition like this can be complex and challenging. Success meant identifying those complexities, figuring out how best to meet those challenges, and remaining agile enough to keep iterating based on regular feedback. Our adoption of React Native was, for all of us at ClassPass, a real lesson in the huge benefits that can accrue from both careful planning and successful adaptation.</p><h3>Buy-in From Key Engineers</h3><p>Changes like this are usually a hard sell to your engineering team. Engineers who are proficient in Swift or Kotlin code don’t want to learn JavaScript or the React framework, particularly when being told to do so by a manager who’s never submitted code to a mobile codebase. It was clear I’d need allies in the engineering team. Two quickly came to mind. The first was a senior iOS engineer who had established himself at ClassPass through technical skill and an eagerness to share his knowledge (he was later promoted to be the mobile lead of ClassPass). The second was a recently-promoted Engineering Manager who was one of the first engineers to see the potential benefits of React Native. Both were much closer to the work, could lead by example, and were well respected by the other mobile engineers.</p><h3>Find Executive Support</h3><p>A large technological shift like this means you also need champions from above. Changes like this can have a huge beneficial impact on the business, but realizing them can take time. There’s the basic learning curve of the language and framework. Time spent hashing out best practices and optimizing operations are vital to the project’s success, but carry opportunity costs. Here’s where ClassPass’ culture of transparency and debate really paid off. We had to clearly articulate the long term business impact this kind of transition would have. Writing code once and launching on both mobile platforms simultaneously would be a huge benefit, especially as we were starting to discuss a major international expansion, where many markets have a much more even distribution of iOS and Android devices than ClassPass’ domestic customer base. Once everyone understood that, the executive and technical stakeholders were now aimed toward the same goal, vastly improving the project’s chance at success.</p><h3>The Learning Curve</h3><p>At the onset of this initiative, I thought it would help if my team could speak to some engineers who had been successful using it. Back in early 2017 that wasn’t easy to find. It had only been two years since Facebook open-sourced React Native. Artsy was one of the few companies that had experience actually using React Native and had spoken openly about it through multiple blog posts. The CTO was a friend, so I reached out and set up some time for our teams to speak. Hearing first hand about their experience gave us more confidence that this technology was viable for ClassPass.</p><p>The team started by using React Native for some smaller features, but we all agreed that some formal training would be valuable. One of our engineers knew of someone who’d led React Native training sessions, and so we scheduled a two-day class. The instructor introduced JavaScript, React, and eventually React Native. Our mobile engineers were very strong, senior, and already had some exposure to React Native; so within a few hours they pushed the instructor into material from the second day. This meant the second day could be used delving into advanced topics. It was great to see the instructor adapt so quickly into a bespoke curriculum based on my team’s desire to better understand advanced concepts like testing and best practices for a “<a href="https://en.wikipedia.org/wiki/Brownfield_(software_development)">brownfield implementation</a>” like ours.</p><h3>The Mandate</h3><p>The team’s success with the training and these smaller projects convinced me we were on the right track but that I needed to keep pushing to make this happen. If each engineer had discretion to use React Native or write native code, many would choose native because it’s what they already knew. If that happened, we would have never realized the full benefits of React Native.</p><p>So the mandate I laid out was simple: Use React Native for all new projects on mobile and come speak to me when you think there should be an exception. The team’s reaction was mixed. Some engineers were excited about it and excited to learn something new, while others were skeptical. But the skepticism was kept to a manageable amount due to the mobile lead and the manager being on board, having gone through the training, and having completed some smaller features in React Native.</p><p>There was one clear exception to the React Native mandate from the beginning. Our Special Projects group were building a live video streaming product that used biometric feedback from body sensors via bluetooth. The work they were doing had deep integrations into the mobile operating systems, and was therefore not a good candidate for React Native. This exception was clear and non-controversial, and I was curious when we would find another clear exception. It took a full year.</p><h3>Operations</h3><p>At this point we had three repositories (iOS, Android, React Native). As we launched more of our features in React Native we faced more operational difficulties. For example, React Native code was pulled into the iOS and Android repos based on a pinned commit hash. This usually resulted in a broken build when an engineer updated the commit hash on either repo. And trying to proactively run UI tests for React Native code against both apps became a manual and time consuming process.</p><p>After much discussion in the mobile guild, it was decided the time had come for the “monorepo”. This would be a large project, but a necessary one if we were to get the most out of React Native. The guild lead broke it down into some releasable milestones and over a few months we had monorepo up and running.</p><p>In the new world of one mobile repository, changes to React Native code triggers a build to be run for both iOS and Android. Since UI tests are run against both apps, we ensure that master is always functioning for both iOS and Android. Code reviews are more productive since you can see what’s changing across platforms in one PR instead of three. Once we made this change, builds weren’t broken or full of terrible surprises. This was even more valuable for builds tied to our app releases. Reducing these issues helped our engineering velocity immensely. Engineers expect to catch their own bugs during a build. But when they find other people’s bugs, they have to reach out and both engineers are interrupted. Productivity takes a big hit and everyone gets frustrated. The new monorepo kept our mobile engineers much more productive and happy.</p><h3>The Feedback Loop</h3><p>Discussing and capturing feedback was a key part of our successful transition to React Native In addition to the large operational changes like the monorepo and the subsequent work on UI tests, many smaller decisions were made regularly. The mobile guild was the primary forum for these conversations. The mobile guild lead’s role in promoting and facilitating these discussions was critical. We also instituted longer “state of the union” meetings twice a year that were entirely focused around React Native. All of these mechanisms for capturing feedback would then feed into action items. Sometimes those actions were establishing and documenting best practices; at other times they were turned into projects on the mobile guild roadmap.</p><p>It’s always important to separate naysaying from valuable critical feedback. Interestingly, throughout our transition, the amount of criticism an engineer had about React Native was inversely proportional to how often they used it. The biggest naysayers used it the least, and tended to like it more as they used it more. Distinguishing naysaying from good feedback was also a product of knowing the engineers very well. I made it a priority to have regular one-on-one meetings, observe them directly in guild meetings, and talk about them with managers. With all of this input, it wasn’t too hard to distinguish legitimate critical feedback from simple personal preference.</p><h3>Mobile Acquisition Flows and Concurrent Development</h3><p>For years our app was only usable by subscribers. We’d acquire users on the web, who’d then use one of our apps to search for and reserve classes. We had recently “opened up” the iOS app and added a number of flows where you could sign up for a trial subscription upon opening the app or several other points in the process of searching for classes. This was a huge shift for ClassPass and our apps soon became a significant source of user acquisition. As we were about to start launching in markets with much more Android usage, it was critical that this work be ported over as soon as possible.</p><p>The mandate meant that all of this code was written in React Native, but the team that built it only had iOS engineers who were expected to launch it in the iOS app with an aggressive deadline. Because it was React Native we assumed it would be easy to port it to Android. This was a pivotal moment for mobile development at ClassPass because it showed great progress but also exposed some major issues. Android engineers were able to get the new flows into the app with roughly 25% of the effort (Two engineers in one month vs four engineers in two months). This was such a clear win for the business and for the team, that most of the skepticism around React Native evaporated. But it had also been a very frustrating month for those Android engineers. The frustration stemmed from our use of the “bridge” and the development of React Native code that was written only for iOS.</p><p>The bridge is the mechanism for passing data between the native world and the React Native world. Since both our mobile apps started as native apps, the bridge is used on all transitions from one view to another. But using the bridge causes latency. It also means that bridge modules have to be duplicated in each native codebase. In this case, Android engineers had to go into the native iOS code and try to figure out what the bridge module was doing and then attempt to replicate that in Java. One of the most important action items that emerged from this project was that we needed to adopt patterns that minimize the use of the bridge. It was also clear that it was much more efficient to work on iOS and Android in parallel, rather than developing for one platform and then porting that code over at a future date. Many React Native components have either iOS or Android specific configurations, and in this project engineers would run into components that were configured for iOS but not Android which slowed down development and was generally a frustrating experience.</p><p>Opening up our mobile apps for user acquisition was the last big project before we were ready to start developing features concurrently on both platforms. The experience and frustration our Android engineers had in porting over these user acquisition flows only reinforced that concurrent development was a move in the right direction.</p><h3>The Next Exception</h3><p>In early 2019 we completely rebuilt our search experience. Client-side development started in React Native as per the mandate. But early in this rewrite the mobile engineers saw latency in the search UX and started to doubt that React Native was going to work for this project. Tickets had been written and engineering work had already started, but now we were questioning what language to use. The product manager for search immediately flagged this a risk. A meeting was scheduled to discuss how to move forward. Because this topic touched both the search project and the mobile guild, most members of both groups came. It was a large meeting and I could tell a lot of people felt tense, like they were about to witness a React Native showdown.</p><p>The meeting started with an engineer on the search project describing the latency issue. Almost immediately the Engineering Manager who was the advocate for React Native (but was not involved in the search project) just stated that we clearly shouldn’t use it for this project. There was some silence and it seemed that people were surprised. They were expecting drama but they got quick agreement. Another senior engineer then said, “React Native is just a tradeoff between latency and development speed”. I thought that was perfectly articulated. I said as much and that I agreed with the decision not to use React Native for our search experience. I was thrilled that we finally found our second exception because it finally drew some sensible rules for when we use React Native. It all came back to the bridge.</p><p>Our search results page is very interactive. Most searches in large markets result in a seemingly infinite scroll of results. You can also swipe left and right to move to search results for different days, and there are other filter controls at the top of the page. All that interactivity requires moving data over the bridge and slows down the app. Most of the work we had done successfully in React Native were simple flows of one screen to another, or larger and more static pages like details pages for venues or classes. I had asked the team to use React Native unless they thought they had a good reason not to. We finally found another reason. Screens with a lot of interactivity should be done natively. ClassPass still defaults to React Native, but now there are more obvious guidelines for when we stick with native.</p><h3>The results</h3><p>Roughly 75% of all mobile development at ClassPass now happens in React Native. Our monorepo and suite of UI tests ensure we are testing React Native code against both apps for all builds. In our Growth squad, almost all mobile development is done in React Native; this has been transformative as almost all mobile work we do improves user conversion. All of this work is done twice as fast as it would be if we still had two fully native codebases. Code can be written once and deployed on both iOS and Android at the same time, and we plow through the roadmap twice as fast as we did two years ago.</p><p>I am not a React Native evangelist. As an engineering leader you need to make technology decisions with the best interest of the business in mind. As engineers we are literally building the business and, in the case of mobile app development at ClassPass, React Native was the right tool for the job.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MVmsLGqugfrFVBWzfWfhOg.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=969391f0af97" width="1" height="1" alt=""><hr><p><a href="https://medium.com/swlh/the-move-to-react-native-969391f0af97">The Move to React Native</a> was originally published in <a href="https://medium.com/swlh">The Startup</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[People Problems]]></title>
            <link>https://medium.com/the-ascent/people-problems-b3dae58409bf?source=rss-70540cefffac------2</link>
            <guid isPermaLink="false">https://medium.com/p/b3dae58409bf</guid>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[management]]></category>
            <category><![CDATA[engineering]]></category>
            <dc:creator><![CDATA[Matthew Eckstein]]></dc:creator>
            <pubDate>Tue, 19 Jul 2016 16:24:29 GMT</pubDate>
            <atom:updated>2020-04-18T01:46:23.437Z</atom:updated>
            <content:encoded><![CDATA[<p>Three months into a new role as the CTO of a small media company, I walked into the CEO’s office and told him that one of our senior engineers had quit. As he started to reassure me that everything would be ok, I quickly cut him off. “I just avoided the most difficult issue I was going to have to deal with in my first six months. I just won the lottery.” Clearly not the response he was anticipating. So I explained that despite being a good engineer, he was difficult to work with, disrespectful to his peers, and did not enjoy collaborating with anyone on the team. In short, he was toxic to the team and we got very lucky that he decided to leave.</p><p>I knew going into the role that there were fundamental issues that had to be fixed ranging from poor software architecture to a complete lack of process on the product and engineering teams. As challenging as those types of problems are, they are nothing compared to people problems.</p><p>People assume the biggest challenges for a CTO or VPE are technical ones. Technical challenges can be hard to solve, but they are also fun to solve. Engineers are at their best when faced with a seemingly unsolvable problem. People problems are not fun for anyone, and unfortunately, are often insoluble.</p><p>Another people problem emerged recently. Unlike the first situation where the guy was a straight-up jerk, disrespectful, unprofessional, and someone who took pleasure in actively putting down his peers — this engineer had the best intentions. He was always looking to improve things and deliver quality software. The problem was that, despite this, he was a poor cultural fit for the team; a much more difficult situation.</p><p>My initial look at the situation gave me only a partial understanding of the problem. It seemed like this engineer had strong opinions that just happened to deviate — often heavily — from those of the rest of the team. His approach to almost every aspect of developing software was just different.</p><p>But what frustrated the other team members most was less about the technical particulars and more about how he collaborated — or rather, how he failed to collaborate — with the rest of the team. Often, other engineers would describe his behavior as “<a href="https://en.wiktionary.org/wiki/bikeshedding">bikeshedding</a>”. (A wonderful term, click through if you aren’t familiar). His believed he was being thoughtful, seeking out discussion, trying to make everything better. But functionally, he was consistently turning simple conversations into big discussions regardless of the topic. From larger architectural issues to coding styles — even how people should word their commit messages — he would initiate a discussion that rarely led to a conclusion or even a next step beyond more discussion.</p><p>After gaining a better perspective on the conflicts it was clear the tension on the team was getting to be too much, and something had to be done immediately. I did not want to lose the contribution of a good engineer, and I thought I could solve the problem by moving him to a project where he wouldn’t have to collaborate. He’d be working with only one other person — a product manager and recent engineer who could do code reviews but would no longer offer engineering-related opinions. I was curious how this engineer would do working alone, in a situation where collaboration wasn’t even possible. Unsurprisingly, he did much better.</p><p>This went on for a few months, but ultimately projects and priorities shifted around and it was no longer an option to keep only one engineer on this project. As soon as other engineers were introduced, the exact same issues came up again. It occurred to me that I’d just been postponing the problem. That said, the time afforded me the opportunity to speak to this engineer more often and learn more about how he approached his work. When tensions (inevitably) arose again, I had much more useful information to inform my decisions.</p><p>I realized that my initial assumption — that this engineer had a different, but equally effective, way of doing things and that it was my job to make the best use of his contributions — was simply wrong. With more time and more conversation with him, I came to understand that his approach to work was more than just a fundamental misfit with our team. The first big revelation was that he conflated best practices with personal preferences. He could spend five minutes or a full hour arguing with other engineers for his approach, but at no point was he ever going to consider the other engineer’s opinion. He also made issues out of very small things, things that no other engineers on the team felt were worthy of discussions. (One of the more notable ones was how and when we should update our statuses in the #status channel on Slack. When the rest of the team blew-off his incredibly specific recommendations of how we should all speak to each other, he petulantly left the channel.) He always spoke about collaboration, but actual collaboration was beyond him. He would relentlessly push his own ideas on everyone else under the banner of collaboration, but that was the exact opposite of true collaboration. There was a disconnect.</p><p>It wasn’t all making mountains out of molehills. He also tended to over-engineer solutions at the onset of a project. Rather than take the simplest approach — develop working software, and refactor later as needed — he would “pre-factor” overly-complex solutions. This fit very poorly with with a team that believed in simple solutions and an iterative process.</p><p>As my understanding of the issue grew, our conversations got more difficult. It was then he started to demonstrate one of the most troubling and toxic behaviors of all: blaming others. He blamed everyone and everything. He argued that the root cause of the conflicts were due to the flaws of other engineers, or being the only one who “cares about the craft”. He cited being a remote worker as a cause. When I pointed out that these conflicts never arose with the other remote team members, he fired off other reasons why this was someone (anyone) else’s fault. There was no introspection, ever.</p><p>Functionally, in the end, this engineer’s problem ended up being the same as the first one. When push came to shove, he didn’t play well with others. And at this point, I knew that the situation was unfixable. To be honest, I’d probably known it for several weeks but I tried — possibly to a fault — to figure out a way to make it work. Why? I’ve been much less forgiving with other people that have wound up leaving the team I’m running, but for some reason I had a hard time getting past this engineer’s good intentions. I think it was because he framed everything as a commitment to quality, which is an ethic I hold in high regard.</p><p>The most valuable thing I took away from this experience was a strong reminder about the importance of cultural fit on a team. The first engineer was an aggressive jerk who took pleasure in putting down others. The second was a really nice guy who thought he was making things better. Both created a toxic environment that was a contributing factor to valuable engineers leaving the organization. In the end, intentions didn’t matter, and paying too much consideration to them only prolonged a bad situation.</p><p>Unlike technical problems, people problems are often insoluble. Ultimately the best resolution is often removing the person from the team quickly. And also unlike technical problems, that is never fun.</p><p><em>Matthew Eckstein is the CTO of charity: water and doesn’t care what color you paint the bike shed.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*78fn-a1uXJT8Fmk7nGD4Iw.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b3dae58409bf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-ascent/people-problems-b3dae58409bf">People Problems</a> was originally published in <a href="https://medium.com/the-ascent">Ascent Publication</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Five Outcomes of Working with Agility]]></title>
            <link>https://medium.com/the-ascent/five-outcomes-of-working-with-agility-17f91c33e58a?source=rss-70540cefffac------2</link>
            <guid isPermaLink="false">https://medium.com/p/17f91c33e58a</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Matthew Eckstein]]></dc:creator>
            <pubDate>Wed, 20 Apr 2016 01:11:29 GMT</pubDate>
            <atom:updated>2020-04-18T01:51:23.902Z</atom:updated>
            <content:encoded><![CDATA[<p>Last year a company reached out to me for advice on their software development practices. They admired my organization’s ability to build engaging and usable products, and asked if I could meet with them to explain how our software engineering team worked to accomplish this.</p><p>I was asked to open the meeting with an overview of our processes and practices. While I could tell that their team was very engaged, they also seemed a little nervous — opening yourself up to criticism from an outsider isn’t easy. A few minutes into the overview I mentioned “Agile”. Instantly the tension in the room lifted and everyone seemed suddenly at ease. <strong>“We use Agile too!”</strong> The meeting proceeded and spirits continued to improve as they recognized key terms from my answers — automated testing, retrospectives, test-driven development, daily stand-ups — that they, too, used.</p><p>A few months later this organization put out a website and a native app to support a heavily promoted event. It was a disaster. It had broken images and videos; it loaded slowly and had a non-intuitive UX. The native app was even worse. It barely functioned at all and content that was supposed to update in real-time remained stagnant from a few days before the event to a few days after the event (maybe forever — I stopped checking after a while). They had released broken software to their users after spending a considerable amount of resources building and promoting it.</p><p>I thought back to the meeting and how it clearly didn’t help them. It made me realize that explicitly talking about Agile methodologies was the wrong approach. Ask a bunch of software engineering managers if their Agile practices are working. They will all say yes. Everyone thinks they work with agility, so asking the question is as meaningless as asking a bunch of people if they are smart or if they have a good sense of humor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o0cmv8S1sHOx6QAJmGemVA.jpeg" /><figcaption>Everyone thinks they’re agile</figcaption></figure><p>As I thought more about it, it occurred to me that a focus on the outcomes of a good Agile process would have been much more productive. Here are five outcomes that I believe show you are truly working with agility.</p><p>1) <strong>The process is always changing</strong></p><p>Agile is about constant improvement and adapting to change. These only happen when every member of the team feels empowered to suggest improvements. If the process remains stagnant for a few months you have either failed to foster a “safe to try” environment, you lack a forum for people to suggest change, or your team does not feel invested in the process.</p><p>Our software engineering teams always have weekly retrospectives. Thirty minutes are set aside every Friday afternoon to discuss what was good, bad, or confusing; and what actions should be taken the following week to make improvements. We are constantly applied to the task of making small changes to our process. Half the time we decide to revert the change. The other half of the time we stick with the change and continue to build from there. Week-to-week things don’t change very much, but year-to-year the cumulative improvements to our process are noticeable, as is the team’s increased effectiveness.</p><p>2) <strong>Clarity is pushed up the chain</strong></p><p>Too often it’s the software engineer that exposes incorrect assumptions, unanswered questions, or other issues that act as blockers to building something. Such flaws often permeate through the entire system right up until the last possible moment, which is, of course, the worst possible moment. Waiting until someone starts to write code to discover these shortcomings is a clear sign the process has failed.</p><p>Well-implemented Agile practices help prevent this by pushing clarity up the chain. A test-driven development approach allows an engineer to discover issues before they begin writing code. But this clarity can be pushed even further up the chain. By writing user stories with clear and detailed acceptance criteria, this clarity can be achieved as the features of the product are still being defined.</p><p>For example, our organization involves the engineers as stories are put into the backlog. Sometimes we discuss implementation, but we always make sure all the engineers have an opportunity to challenge the story. This small investment of time upfront saves a lot of time that would be spent uncovering issues later.</p><p>We also include the engineering team in a process called “<a href="https://blog.pivotal.io/labs/labs/agile-inception_knowing-what-to-build-and-where-to-start">inception</a>” that we use to start new projects. Getting engineers involved at the outset not only makes them more invested in the project, but it also allows them to make valuable contributions to the “why” as well as the “how” by contextualizing those contributions from the start.</p><p>3) <strong>Agile principles spread to other parts of the organization</strong></p><p>If any team or department in an organization is highly productive, other people take notice. They start to ask questions and become curious about how they, too, can start to work with agility. At our organization people consistently notice the engineering team’s ability to make small chunks of progress very quickly and with confidence. Other departments ask us to run workshops to surface their own team’s true priorities. Our marketing team talks about minimum viable products. And our CEO went from asking us to build new products and features to asking us if we can run A/B experiments to test his ideas. A department run with agility becomes an excellent incubator.</p><p>4) <strong>Usable software is pushed to production daily</strong></p><p>Software should be pushed into production every single day. Even if your industry has regulations that prevent this, code that is deemed ready for production by the engineer who wrote it should be committed every day.</p><p>This will produce hard evidence that your work is being done in small, logical chunks. We make sure that every user story could be pushed to production on its own even if it’s part of a very large project. We do this with feature flags or by simply knowing that the code will not get called. It also means your user stories aren’t too big. When the engineers point stories (1,2,3,5,8), a value of 8 almost always means that the story should be broken into multiple stories. If it’s common for engineers to work on the same story for multiple days, you are not breaking up your work into small enough chunks. And when work isn’t broken down into small enough pieces, complexity gets overlooked and becomes an issue later.</p><p>5) <strong>Less talking, more doing</strong></p><p>It’s all too common for people to try to solve a complex issue by “getting into a room together.” Most of these meetings probably happen without any kind of structure directed toward meaningful decision-making. We’ve all participated in such meetings. Everyone going into a meeting should be able to explain the goal of that meeting.</p><p>Too many emails is also a bad sign. At a previous job, I witnessed an email chain for a big project between 20 people that topped out at over 100 individual emails. The subtext of every email was, “I just did this thing, and I don’t know what’s supposed to happen next.” Too much communication without clear results is a strong indicator that your process is not working.</p><p>When done well, working with agility can be a powerful and transformative force. But software engineering managers all too often implement something basic, check the “Agile” box, and walk away. They forget that working with agility means testing, learning, and iterating not only the product, but the process itself. It’s about responding to change. If you’re not doing the responding part, you are not doing Agile. The five outcomes above are good indicators that you are truly working with agility.</p><p><em>Matthew Eckstein is the CTO of </em><a href="http://www.charitywater.org/"><em>charity: water</em></a><em> and loves a good process.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=17f91c33e58a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/the-ascent/five-outcomes-of-working-with-agility-17f91c33e58a">Five Outcomes of Working with Agility</a> was originally published in <a href="https://medium.com/the-ascent">Ascent Publication</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>