 <p> <span class=\"drop-cap\">O</span>ur daughter was born at 5:22  <span style=\"font-variant: small-caps\"> p.m. </span>  on December 30, 2005. Two hours later, a nurse called my husband out of the room. When he returned, he took my hand and said, “They think Penny has Down syndrome.” As this news began to make its way into my consciousness, we heard shouts from the room next door. Another child had been born. “She’s perfect!” someone exclaimed about that other baby. “She’s perfect!” </p><p> Once we found out that Penny had Down syndrome, we had a hard time celebrating her birth. We didn’t open the bottle of champagne perched by my bedside. We were afraid to call our friends and family. We didn’t shout, “She’s perfect.” </p><p> In fact, those words haunted me. The medical language used for Down syndrome implies a special brand of imperfection: “disabled,” as if Penny were a defective piece of machinery that had been turned off; “retarded,” with all its connotations of stupid and subhuman; “abnormal,” like a cancerous growth. I found no comfort in these terms.  </p><p> My faith didn’t help much either. Without even knowing it, my mind held a theological grid, a mental chart of how the universe worked. The only thing that chart told me about Down syndrome—the presence of an extra chromosome in every cell of Penny’s body—was that it was a manifestation of sin in the world. By that, I don’t mean I thought Down syndrome was immoral, but I did think that, because the entire cosmos was out of whack, bad things happened. Bad things, like malaria, and hurricanes, and extra chromosomes. And if having an extra chromosome was on par with disease and destruction and other things that are not of God, what did that say about our daughter?  </p><p> <span class=\"drop-cap\"></span>My theology, at first, seemed to affirm the medical language. It seemed that, even by God’s standards, Penny was in another category of human being altogether—not merely “fallen,” like the rest of us, but defective, a mistake. And yet even in those early, dark hours of her life, Penny’s presence—her sweet face and tiny hands and warm body—knocked against my grid, jostled my presuppositions about human wholeness and human sin. I started to understand that Penny was a gift, a precious human being, a child with much to offer.  </p><p> <span class=\"drop-cap\">I</span> began to reconsider my own theological presuppositions. And I wondered—Was Down syndrome a product of cosmic disorder? What did it mean for Penny, extra chromosome and all, to be created in the image of God? Could Down syndrome have existed in the Garden of Eden? Would Penny have Down syndrome in heaven? In other words, was Down syndrome a part of God’s good creation, or was it evidence of creation gone awry?  </p><p> I wasn’t the only one asking these questions. Amos Yong’s  <em> Theology and Down Syndrome</em>, Thomas Reynolds’  <em> Vulnerable Communion</em>, and Hans Reinders’  <em> Receiving the Gift of Friendship  </em> have all been published within the last year, and all consider theological questions surrounding both physical and mental disability. Together these writers provide a nuanced understanding of what it means to be human and what it means to anticipate a fully redeemed and restored, perfected humanity. </p><p> Before I read these books, and before Penny was in my life, I thought of perfection in largely individualistic and physical terms, as if one day God’s redeeming work would make us all little superheroes—strong, beautiful, intelligent, and incapable of making mistakes. These authors, however, recognize the full and even exemplary humanity of the individuals our culture calls disabled. They recognize the significance, both here and now and for all eternity, of “the least of these.” Yong explains, “The world, as created, is contingent, limited, and finite (as opposed to the divine infinitude). Yet contingency, limitedness, and finitude are not essentially evil, even if the human experience of suffering (and evil) is sometimes derived from these realities.” </p><p> In other words, from the moment of creation, human beings have been needy and dependent creatures. The initial sin of Adam and Eve was to attempt to become like God instead of accepting their inherent limitedness as humans. Rather than trusting God to direct and guide them within their natural limits, they tried to become autonomous individuals. As Reynolds writes, “Neediness, vulnerability, or lack of ability is not a flaw detracting from an otherwise pure and complete human nature. Rather, it is testimony to the fact that our nature involves receiving our existence from each other.” To think of the first humans in terms of dependence, need, and vulnerability makes me wonder whether Adam could have stubbed his toe, or whether he ever asked Eve for a backrub to relieve his sore muscles after a long day’s work. It helps me realize that human limitations didn’t arise when sin entered the world. Limitations existed already. It was brokenness—both within the moral and the natural order—that came with sin. </p><p> Just as Adam’s and Eve’s limitations constitute one aspect of their humanity, the life, death, and resurrection of Christ provide a portrait of humanity that includes vulnerability, weakness, and powerlessness. Scriptural references to Christ’s power in weakness abound: Think of the hymn in Philippians 2, or the image from Revelation of the saints worshiping “the lamb that was slain.” According to Yong, since Jesus experienced bodily disfigurement on the cross, “this Christologically defined  <em> imago Dei </em>  would thus be inclusive rather than exclusive of the human experience of disability.”  </p><p> <span class=\"drop-cap\"></span>Reynolds makes a similar point: “His resurrected body continues to bear his scars as a sign of God’s solidarity with humanity . . .  . It suggests that disability indicates not a flawed humanity but a full humanity.” It is true, and significant, that Christ comes to us in weakness, with limits, and with needs, and yet I wouldn’t claim Jesus is “the disabled God.” Christ’s physical suffering is imposed on him by humans, whereas disability often refers to congenital and genetically based physical problems. Moreover, he does not remain in this incapacitated state. The resurrected Christ bears his scars, but he does not retain his wounds. </p><p> Yong and Reynolds both go too far in arguing the solidarity of Christ’s suffering and human disability. And yet, the images of both Adam and Christ as limited and vulnerable allow us to conceive humanity in different terms from those I had on hand when I found out Penny had Down syndrome. At first, I could only see her extra chromosome as evidence of imperfection, as a series of limitations that were different and worse than my own human limits. I didn’t conceive of limits—hers or mine—as potentially good: gifts from God that enable each of us to admit our creatureliness, our need for one another, our need for God’s grace.  </p><p> Early on, I had asked my mother whether she thought Down syndrome happened because of sin in the world. She responded gently, “The only evidence of sin I see is in how the world reacts to Penny.” I began to understand what she meant—that Penny is no more or less human than I am, no more or less born in sin, no more or less blessed, no more or less in need of redemption. When I think of Penny’s life to come only in terms of being fixed or healed, I miss the point of what it means for God to redeem and heal each and every one of us. </p><p> <span class=\"drop-cap\">I</span> have been asking the wrong questions all along. We know that heaven involves seeing God face to face. We know it involves love. We know it involves participation in community, in the body of Christ, within a multiplicity of gifts and abilities. We also know that, even once we are fully redeemed, our humanity includes limitations and dependence on one another. We don’t know what those limits will look like. We don’t know whether all of us will have good vision or be able to run marathons without feeling tired or be able to solve quadratic equations. Yong goes so far as to say, “I further speculate that people with intellectual or developmental disabilities, such as those with Down syndrome or triplicate chromosome 21—will also retain their phenotypical features in their resurrection bodies . . .  . Thus, the redemption of those with Down syndrome, for example, would consist not in some magical fix of the twenty-first chromosome but in the recognition of their central roles in the communion of saints and in the divine scheme of things.” </p><p> With all that said, we also know that God promises to make us whole. So when the prophet Isaiah writes of a future when the blind will be healed, or when Jesus heals the paralytic, or when the author of Revelation envisions the new heaven and the new earth without any pain, I have to wonder where healing fits in my new understanding of Down syndrome and other disabilities. All three of the recent books imply that when we conceive of healing simply as miraculous cures for abnormal states of being—blindness, deafness, cognitive delays—we miss the point. They do not see the transformation of every physical limitation as a guarantee, or even as necessary for fulfilling our human potential, and they construe healing in a holistic sense, as the inclusion of all people, regardless of bodily or mental function, in communion with God.  </p><p> I can’t say what Penny’s redemption will look like, and I trust that God’s promise to make each one of us whole will include physical transformation. But part of the point is to remind ourselves about the full humanity of those with Down syndrome in this world. It took a lot of thought and prayer for me to agree with what my mother understood as soon as Penny was born: The evidence of sin is in our response to her, not in her extra chromosome.  </p><p> For a long time, I was looking for answers to questions that were hardly worth asking, and I was trying to recreate my daughter according to a cultural standard of normalcy rather than according to a biblical understanding of full human life. We are created in the image of God, recipients of divine love and grace, and we bear the responsibility and privilege of extending love into the world here and now, and forever more. </p><p> Two and a half years after Penny was born, I don’t think of her as defective, or retarded, or abnormal. I think back to that first evening of her life, when I cringed at the words about the baby next door: “She’s perfect!” I still wouldn’t call Penny perfect. I wouldn’t call any human being, besides Jesus, perfect. I am well aware that Penny needs healing and redemption through Christ, as do I. And Penny’s nature, I hope and pray, will be redeemed through Christ as she becomes the whole person she was created to be. I suspect Penny’s whole person will include three twenty-first chromosomes, but only because any aspect of that extra chromosome causing separation—physical, emotional, relationalwill be overcome. </p><p> Just recently, we started reading a book about Jesus together. We read the story of Jesus blessing the little children. Penny was fascinated. At the end, I told her that Jesus loves her just like he loves the little children in the story. And I asked her if she knows that she can talk to Jesus. Without hesitation, she nodded her head, folded her hands, and said, “Pray.” Now that I know what to look for, I glimpse perfection in Penny’s life nearly every day. </p><p> <em> Amy Julia Becker, a master-of-divinity candidate at Princeton Theological Seminary, is a writer and mother in Lawrenceville, New Jersey. Her first book,  </em> Penelope Ayers,  <em> will be published this fall. </em> </p> 
